1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
 
 
2
 
2
 
 
 
 
 
 
 
1
2
 
 
 
 
 
2
 
 
2
 
 
2
2
 
1
 
 
 
2
 
 
1
1
1
 
1
1
 
 
1
1
 
1
 
 
1
 
2
 
 
 
 
 
1
 
1
 
1
 
 
 
 
1
2
2
3
3
3
3
1
 
 
3
3
 
 
 
 
3
 
 
 
1
3
1
 
 
 
1
1
 
 
 
 
 
 
 
1
 
1
1
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
1
 
 
6
6
 
1
 
2
 
1
 
2
 
 
 
 
1
1
 
1
 
 
 
 
1
 
 
 
 
 
 
1
 
 
1
1
 
 
1
1
 
1
1
1
1
1
1
1
 
1
1
 
1
 
 
 
 
/*
example.js
 
quickstart example
 
instruction
    1. save this script as example.js
    2. run the shell command:
        $ npm install npmtest-altair.io && PORT=8081 node example.js
    3. play with the browser-demo on http://127.0.0.1:8081
*/
 
 
 
/* istanbul instrument in package npmtest_altair_io */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || (local.modeJs === 'browser'
            ? local.global.utility2_npmtest_altair_io
            : global.utility2_moduleExports);
        // export local
        local.global.local = local;
    }());
    switch (local.modeJs) {
 
 
 
    // post-init
    // run browser js-env code - post-init
    /* istanbul ignore next */
    case 'browser':
        local.testRunBrowser = function (event) {
            Eif (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('onreset'))) {
                // reset output
                Array.from(
                    document.querySelectorAll('body > .resettable')
                ).forEach(function (element) {
                    switch (element.tagName) {
                    case 'INPUT':
                    case 'TEXTAREA':
                        element.value = '';
                        break;
                    default:
                        element.textContent = '';
                    }
                });
            }
            switch (event && event.currentTarget && event.currentTarget.id) {
            case 'testRunButton1':
                // show tests
                Eif (document.querySelector('#testReportDiv1').style.display === 'none') {
                    document.querySelector('#testReportDiv1').style.display = 'block';
                    document.querySelector('#testRunButton1').textContent =
                        'hide internal test';
                    local.modeTest = true;
                    local.testRunDefault(local);
                // hide tests
                } else {
                    document.querySelector('#testReportDiv1').style.display = 'none';
                    document.querySelector('#testRunButton1').textContent = 'run internal test';
                }
                break;
            // custom-case
            default:
                break;
            }
            Iif (document.querySelector('#inputTextareaEval1') && (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('oneval')))) {
                // try to eval input-code
                try {
                    /*jslint evil: true*/
                    eval(document.querySelector('#inputTextareaEval1').value);
                } catch (errorCaught) {
                    console.error(errorCaught);
                }
            }
        };
        // log stderr and stdout to #outputTextareaStdout1
        ['error', 'log'].forEach(function (key) {
            console[key + '_original'] = console[key];
            console[key] = function () {
                var element;
                console[key + '_original'].apply(console, arguments);
                element = document.querySelector('#outputTextareaStdout1');
                Iif (!element) {
                    return;
                }
                // append text to #outputTextareaStdout1
                element.value += Array.from(arguments).map(function (arg) {
                    return typeof arg === 'string'
                        ? arg
                        : JSON.stringify(arg, null, 4);
                }).join(' ') + '\n';
                // scroll textarea to bottom
                element.scrollTop = element.scrollHeight;
            };
        });
        // init event-handling
        ['change', 'click', 'keyup'].forEach(function (event) {
            Array.from(document.querySelectorAll('.on' + event)).forEach(function (element) {
                element.addEventListener(event, local.testRunBrowser);
            });
        });
        // run tests
        local.testRunBrowser();
        break;
 
 
 
    // run node js-env code - post-init
    /* istanbul ignore next */
    case 'node':
        // export local
        module.exports = local;
        // require modules
        local.fs = require('fs');
        local.http = require('http');
        local.url = require('url');
        // init assets
        local.assetsDict = local.assetsDict || {};
        /* jslint-ignore-begin */
        local.assetsDict['/assets.index.template.html'] = '\
<!doctype html>\n\
<html lang="en">\n\
<head>\n\
<meta charset="UTF-8">\n\
<meta name="viewport" content="width=device-width, initial-scale=1">\n\
<title>{{env.npm_package_name}} (v{{env.npm_package_version}})</title>\n\
<style>\n\
/*csslint\n\
    box-sizing: false,\n\
    universal-selector: false\n\
*/\n\
* {\n\
    box-sizing: border-box;\n\
}\n\
body {\n\
    background: #dde;\n\
    font-family: Arial, Helvetica, sans-serif;\n\
    margin: 2rem;\n\
}\n\
body > * {\n\
    margin-bottom: 1rem;\n\
}\n\
.utility2FooterDiv {\n\
    margin-top: 20px;\n\
    text-align: center;\n\
}\n\
</style>\n\
<style>\n\
/*csslint\n\
*/\n\
textarea {\n\
    font-family: monospace;\n\
    height: 10rem;\n\
    width: 100%;\n\
}\n\
textarea[readonly] {\n\
    background: #ddd;\n\
}\n\
</style>\n\
</head>\n\
<body>\n\
<!-- utility2-comment\n\
<div id="ajaxProgressDiv1" style="background: #d00; height: 2px; left: 0; margin: 0; padding: 0; position: fixed; top: 0; transition: background 0.5s, width 1.5s; width: 25%;"></div>\n\
utility2-comment -->\n\
<h1>\n\
<!-- utility2-comment\n\
    <a\n\
        {{#if env.npm_package_homepage}}\n\
        href="{{env.npm_package_homepage}}"\n\
        {{/if env.npm_package_homepage}}\n\
        target="_blank"\n\
    >\n\
utility2-comment -->\n\
        {{env.npm_package_name}} (v{{env.npm_package_version}})\n\
<!-- utility2-comment\n\
    </a>\n\
utility2-comment -->\n\
</h1>\n\
<h3>{{env.npm_package_description}}</h3>\n\
<!-- utility2-comment\n\
<h4><a download href="assets.app.js">download standalone app</a></h4>\n\
<button class="onclick onreset" id="testRunButton1">run internal test</button><br>\n\
<div id="testReportDiv1" style="display: none;"></div>\n\
utility2-comment -->\n\
\n\
\n\
\n\
<label>stderr and stdout</label>\n\
<textarea class="resettable" id="outputTextareaStdout1" readonly></textarea>\n\
<!-- utility2-comment\n\
{{#if isRollup}}\n\
<script src="assets.app.js"></script>\n\
{{#unless isRollup}}\n\
utility2-comment -->\n\
<script src="assets.utility2.rollup.js"></script>\n\
<script src="jsonp.utility2._stateInit?callback=window.utility2._stateInit"></script>\n\
<script src="assets.npmtest_altair_io.rollup.js"></script>\n\
<script src="assets.example.js"></script>\n\
<script src="assets.test.js"></script>\n\
<!-- utility2-comment\n\
{{/if isRollup}}\n\
utility2-comment -->\n\
<div class="utility2FooterDiv">\n\
    [ this app was created with\n\
    <a href="https://github.com/kaizhu256/node-utility2" target="_blank">utility2</a>\n\
    ]\n\
</div>\n\
</body>\n\
</html>\n\
';
        /* jslint-ignore-end */
        Iif (local.templateRender) {
            local.assetsDict['/'] = local.templateRender(
                local.assetsDict['/assets.index.template.html'],
                {
                    env: local.objectSetDefault(local.env, {
                        npm_package_description: 'the greatest app in the world!',
                        npm_package_name: 'my-app',
                        npm_package_nameAlias: 'my_app',
                        npm_package_version: '0.0.1'
                    })
                }
            );
        } else {
            local.assetsDict['/'] = local.assetsDict['/assets.index.template.html']
                .replace((/\{\{env\.(\w+?)\}\}/g), function (match0, match1) {
                    // jslint-hack
                    String(match0);
                    switch (match1) {
                    case 'npm_package_description':
                        return 'the greatest app in the world!';
                    case 'npm_package_name':
                        return 'my-app';
                    case 'npm_package_nameAlias':
                        return 'my_app';
                    case 'npm_package_version':
                        return '0.0.1';
                    }
                });
        }
        // run the cli
        Eif (local.global.utility2_rollup || module !== require.main) {
            break;
        }
        local.assetsDict['/assets.example.js'] =
            local.assetsDict['/assets.example.js'] ||
            local.fs.readFileSync(__filename, 'utf8');
        // bug-workaround - long $npm_package_buildCustomOrg
        /* jslint-ignore-begin */
        local.assetsDict['/assets.npmtest_altair_io.rollup.js'] =
            local.assetsDict['/assets.npmtest_altair_io.rollup.js'] ||
            local.fs.readFileSync(
                local.npmtest_altair_io.__dirname + '/lib.npmtest_altair_io.js',
                'utf8'
            ).replace((/^#!/), '//');
        /* jslint-ignore-end */
        local.assetsDict['/favicon.ico'] = local.assetsDict['/favicon.ico'] || '';
        // if $npm_config_timeout_exit exists,
        // then exit this process after $npm_config_timeout_exit ms
        if (Number(process.env.npm_config_timeout_exit)) {
            setTimeout(process.exit, Number(process.env.npm_config_timeout_exit));
        }
        // start server
        if (local.global.utility2_serverHttp1) {
            break;
        }
        process.env.PORT = process.env.PORT || '8081';
        console.error('server starting on port ' + process.env.PORT);
        local.http.createServer(function (request, response) {
            request.urlParsed = local.url.parse(request.url);
            if (local.assetsDict[request.urlParsed.pathname] !== undefined) {
                response.end(local.assetsDict[request.urlParsed.pathname]);
                return;
            }
            response.statusCode = 404;
            response.end();
        }).listen(process.env.PORT);
        break;
    }
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
2
 
2
1
 
1
1
1
 
 
 
 
 
/* istanbul instrument in package npmtest_altair_io */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || local;
        // init lib
        local.local = local.npmtest_altair_io = local;
        // init exports
        if (local.modeJs === 'browser') {
            local.global.utility2_npmtest_altair_io = local;
        } else {
            module.exports = local;
            module.exports.__dirname = __dirname;
            module.exports.module = module;
        }
    }());
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
2
 
 
1
 
 
 
1
 
 
1
 
1
 
 
2
 
 
 
 
 
2
2
 
2
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
2
2
 
2
 
 
 
 
 
1
 
 
 
 
 
 
1
 
 
 
1
 
 
1
 
 
 
 
 
 
1
 
 
 
 
 
 
1
1
 
 
1
 
 
 
 
 
 
1
1
1
1
1
1
 
 
1
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
1
1
 
 
 
1
1
 
 
 
 
/* istanbul instrument in package npmtest_altair_io */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        switch (local.modeJs) {
        // re-init local from window.local
        case 'browser':
            local = local.global.utility2.objectSetDefault(
                local.global.utility2_rollup || local.global.local,
                local.global.utility2
            );
            break;
        // re-init local from example.js
        case 'node':
            local = (local.global.utility2_rollup || require('utility2'))
                .requireReadme();
            break;
        }
        // export local
        local.global.local = local;
    }());
 
 
 
    // run shared js-env code - function
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - function
    case 'browser':
        break;
 
 
 
    // run node js-env code - function
    case 'node':
        break;
    }
 
 
 
    // run shared js-env code - post-init
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - post-init
    case 'browser':
        local.testCase_browser_nullCase = local.testCase_browser_nullCase || function (
            options,
            onError
        ) {
        /*
         * this function will test browsers's null-case handling-behavior-behavior
         */
            onError(null, options);
        };
 
        // run tests
        local.nop(local.modeTest &&
            document.querySelector('#testRunButton1') &&
            document.querySelector('#testRunButton1').click());
        break;
 
 
 
    // run node js-env code - post-init
    /* istanbul ignore next */
    case 'node':
        local.testCase_buildApidoc_default = local.testCase_buildApidoc_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApidoc's default handling-behavior-behavior
         */
            options = { modulePathList: module.paths };
            local.buildApidoc(options, onError);
        };
 
        local.testCase_buildApp_default = local.testCase_buildApp_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApp's default handling-behavior-behavior
         */
            local.testCase_buildReadme_default(options, local.onErrorThrow);
            local.testCase_buildLib_default(options, local.onErrorThrow);
            local.testCase_buildTest_default(options, local.onErrorThrow);
            local.testCase_buildCustomOrg_default(options, local.onErrorThrow);
            options = [];
            local.buildApp(options, onError);
        };
 
        local.testCase_buildCustomOrg_default = local.testCase_buildCustomOrg_default ||
            function (options, onError) {
            /*
             * this function will test buildCustomOrg's default handling-behavior
             */
                options = {};
                local.buildCustomOrg(options, onError);
            };
 
        local.testCase_buildLib_default = local.testCase_buildLib_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildLib's default handling-behavior
         */
            options = {};
            local.buildLib(options, onError);
        };
 
        local.testCase_buildReadme_default = local.testCase_buildReadme_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildReadme's default handling-behavior-behavior
         */
            options = {};
            local.buildReadme(options, onError);
        };
 
        local.testCase_buildTest_default = local.testCase_buildTest_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildTest's default handling-behavior
         */
            options = {};
            local.buildTest(options, onError);
        };
 
        local.testCase_webpage_default = local.testCase_webpage_default || function (
            options,
            onError
        ) {
        /*
         * this function will test webpage's default handling-behavior
         */
            options = { modeCoverageMerge: true, url: local.serverLocalHost + '?modeTest=1' };
            local.browserTest(options, onError);
        };
 
        // run test-server
        local.testRunServer(local);
        break;
    }
}());
 
 

1
2
3
 
2
 
//#!/usr/bin/env node
require('../altair.js');
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
 
 
 
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/**
 * Bootstrap Altair instances based on a config
 */
require(['altair/Altair',
    'require',
    'altair/cartridges/Foundry',
    'altair/facades/mixin',
    'altair/facades/home',
    'altair/plugins/node!debug',
    'altair/plugins/node!path',
    'altair/plugins/node!fs',
    'altair/plugins/node!module',
    'altair/plugins/node!config-extend',
    'lodash',
    'altair/plugins/config!core/config/altair.json?env=' + global.env],
 
    function (Altair, require, Foundry, mixin, home, debugUtil, path, fs, Module, extend, _, config) {
 
        /**
         * Simple debug logging
         */
        debugUtil.enable(config.debug);
        debug       = debugUtil('altair:Altair');
        require.log = debug; //overrides the require.log used by dojo to provide much better high level reporting
 
        /**
         * Make sure our CWD is set
         */
        if(global.cwd !== process.cwd()) {
            process.chdir(global.cwd);
        }
 
        /**
         * NPM has zero dependency injection so it's easier to create a central place for altair to manage
         * all node dependencies than it is to configure npm (at all). This is where all the dependencies
         * for altair modules/themes/widgets/sites will be installed.
         */
        var homePath        = path.join(home(), '.altair'),
            homeConfigPath  = path.join(homePath, 'altair.json'),
            homePackagePath = path.join(homePath, 'package.json'),
            appConfigPath   = path.join(process.cwd(), 'altair.json');
 
        //does our run dir exist? move this to better installer
        try {
 
            fs.statSync(homePath);
 
        } catch (e) {
 
            debug('altair first run, creating ' + homePath);
 
            //create home
            fs.mkdirSync(homePath);
            fs.writeFileSync(homeConfigPath, JSON.stringify({
                description: 'See https://github.com/liquidg3/altair/blob/master/docs/config.md for help on configuring altair.',
                'default': {
                    paths:       {
                        core: 'core'
                    }
                }
            }, null, 4));
 
            fs.writeFileSync(homePackagePath, JSON.stringify({
                name:        'altair-global',
                description: 'Placeholder altair config to hold dependencies of all installed modules.'
            }, null, 4));
 
 
        }
 
        /**
         * Mixin config from app/config/altair.json if there is one
         */
        require([
            'altair/plugins/config!' + appConfigPath + '?env=' + global.env,
            'altair/plugins/config!' + homeConfigPath + '?env=' + global.env
        ], function (appConfig, homeConfig) {
 
            var paths = [],
                altair,
                app,
                foundry;
 
            config.paths.home = homePath; //always have a home path
 
            //inform us about our environment
            debug('current environment is "' + global.env + '".');
 
            //mixin configs, cwd config wins!
            if(appConfig) {
 
                //if the cwdConfig exists, it is our new "home" folder and everything will run/install from there
                debug('app detected - loading config @ ' + appConfigPath);
 
                extend(config, appConfig);
 
                //our new home (also make sure it's in the paths)
                app = process.cwd();
                config.paths.app = app;
 
            } else {
 
                debug('loading config @ ' + homeConfigPath);
                config = mixin(config, homeConfig);
 
            }
 
            /**
             * Lets you configure how much error reporting to do.
             *
             * @type {number}
             */
            Error.stackTraceLimit = config.stackTraceLimit || Infinity;
 
 
            //set debug config again
            debugUtil.names = [];
            debugUtil.skips = [];
            debugUtil.enable(config.debug);
 
            /**
             * Make sure npm can look at our current app directory, fallback to home. But NEVER both.
             *
             * @type {string}
             */
            process.env['NODE_PATH'] += ":" + path.join(homePath, 'node_modules');
            if(app) { //app (which is cwd if altair.json exists) is a valid lookup spot
                process.env['NODE_PATH'] += ":" + path.join(app, 'node_modules');
            }
            Module._initPaths(); // terrible
 
            /**
             * Bring in the packages from the config, this should point to at least app and core. Even though core is not
             * needed, this array is also used to build our lookup paths in altair. Altair only needs their names since
             * dojo's define() and require() can map it to their paths.
             */
            require({
                paths: config.paths
            });
 
            //cartridges are given a key in the config so they can be overridden easier.
            config.cartridges = _.toArray(config.cartridges);
 
            //paths by name for altair
            Object.keys(config.paths).forEach(function (name) {
                paths.push(name);
            });
 
            /**
             * Startup the cartridge factory and create the cartridges, then add
             * them to altair.
             */
            altair  = new Altair({ paths: paths, safeMode: global.safe, home: homePath });
            foundry = new Foundry(altair);
 
            if (altair.safeMode) {
                debug('-- starting altair in safe mode --');
            }
 
            debug('creating cartridge foundry. adding ' +  config.cartridges.length + ' cartridges.');
 
            foundry.build(config.cartridges).then(function (cartridges) {
 
                debug('cartridges created. adding to altair for startup.');
 
                /**
                 * Add cartridges
                 */
                return altair.addCartridges(cartridges).then(function () {
 
                    debug('cartridges started.');
 
                });
 
            }).otherwise(debug);
 
        });
 
 
    });
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
 
 
 
 
 
 
 
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/**
 * Well, this is it... Altair in its entirety. The whole platform is simply a cartridge loader. These cartridges are
 * responsible for enhancing the environment in various ways. It should be really easy to augment the platform at a very
 * low level this way. Chances are that if you need to add new functionality into the platform you should be doing it
 * as a module. The only things that should be cartridges are components that need to exist before the module system
 * is ready. Currently, this is things like Nexus (Dependency Injection), Apollo (ORM), Cache, Database, and a few others.
 * See core/config/altair.json to see the current config.
 */
define(['altair/facades/declare',
    'altair/Deferred',
    'lodash',
    'altair/facades/hitch',
    'altair/facades/home',
    'altair/facades/all',
    'altair/facades/when',
    'altair/plugins/node!path',
    'altair/events/Emitter'
],
    function (declare, Deferred, _, hitch, home, all, when, path, Emitter) {
 
        //helper for us elsewhere *find better place*
        _.isObjectLiteral = function (_obj) {
            var _test  = _obj;
            return (  typeof _obj !== 'object' || _obj === null ?
                false :
                (
                    (function () {
                        while (!false) {
                            if (  Object.getPrototypeOf( _test = Object.getPrototypeOf(_test)  ) === null) {
                                break;
                            }
                        }
                        return Object.getPrototypeOf(_obj) === _test;
                    })()
                    )
                );
        };
 
        "use strict";
 
        return declare([Emitter], {
 
            _cartridges: null,
            env:         'dev',
            paths:       null,
            safeMode:    false,
            home:       '',
 
            constructor: function (options) {
 
                var _options = options || {};
 
                this.paths = _options.paths || [];
                this.env = _options.env || 'dev';
                this.safeMode = _.has(_options, 'safeMode') ? _options.safeMode : false;
                this.home = _.has(_options, 'home') ? _options.home : path.join(home(), '.altair');
 
                this._cartridges = {};
            },
 
            /**
             * Resolve a path against  the last path in my paths. home by default
             *
             * @param p String
             * @returns {String}
             */
            resolvePath: function (p) {
 
                var resolved = p;
 
                //if it starts with ./, then assume it's from the current working directory
                if (p[0] === '.') {
                    resolved = path.join(process.cwd(), p);
                }
                //relative paths (no /) all look from app or home
                else if(p[0] != path.sep) {
                    resolved = path.join(require.toUrl(this.paths[this.paths.length - 1]), p);
                }
 
                return resolved;
 
            },
 
            /**
             * Add an un-started cartridge and I'll add it to the system and start it up. optionally i will execute it.
             *
             * @param cartridge
             * @param execute should I execute the cartridge after startup??
             * @returns {altair.Promise}
             */
            addCartridge: function (cartidge, execute) {
 
                this._cartridges[cartidge.name] = cartidge;
 
                return cartidge.startup().then(function (cartridge) {
                    if (execute !== false) {
                        return cartridge.execute();
                    } else {
                        return cartridge;
                    }
                });
 
 
            },
 
            /**
             * Removes a cartridge, but tears it down first.
             *
             * @param key
             * @returns {altair.Promise}
             */
            removeCartridge: function (name) {
 
                var def = this.cartridge(name).teardown();
 
                delete this._cartridges[name];
 
                return def;
 
            },
 
            /**
             * All the cartridges by name.
             *
             * @returns {object}
             */
            cartridges: function () {
                return this._cartridges;
            },
 
            /**
             * Get a cartridge by it's key
             *
             * @param key
             * @returns {*|null}
             */
            cartridge: function (name) {
                return this._cartridges[name] || null;
            },
 
            /**
             * Is this cartridge loaded?
             *
             * @param name
             * @returns {boolean}
             */
            hasCartridge: function (name) {
                return !!this._cartridges[name];
            },
 
            /**
             * Quick check if all the cartridges are loaded. If any single one is missing,
             * it returns false.
             *
             * @param namees
             * @returns {boolean}
             */
            hasCartridges: function (namees) {
 
                var i;
 
                for (i = 0; i < namees.length; i++) {
                    if (!this.hasCartridge(namees[i])) {
                        return false;
                    }
                }
 
                return true;
            },
 
            /**
             * Add a collection of cartridges. Each cartridge will be started up AFTER the one before it. This is to ensure
             * dependencies are in place before dependants are loaded.
             *
             * @param cartridges
             * @returns {altair.Promise}
             */
            addCartridges: function (cartridges) {
 
                var deferred = new Deferred(),
                    deferred2 = new Deferred(),
                    started = [],
                    add = hitch(this, function () {
 
                        var cartridge = cartridges.shift();
 
                        if (cartridge) {
                            started.push(cartridge);
                            this.addCartridge(cartridge, false).then(add).otherwise(hitch(deferred, 'reject'));
                        } else {
                            deferred.resolve(this);
                        }
                    });
 
                add();
 
                //execute module
                var execute = hitch(this, function () {
 
                    var cartridge = started.shift();
 
                    if (cartridge) {
                        when(cartridge.execute()).then(execute).otherwise(function (err) {
                            deferred2.reject(err);
                        });
                    } else {
                        deferred2.resolve(this);
                    }
                });
 
                return deferred.then(hitch(this, function () {
 
                    execute();
                    return deferred2;
 
                }));
 
            },
 
            /**
             * Teardown every cartridge.
             *
             * @returns {*}
             */
            teardown: function () {
 
                var l = _.map(this._cartridges, function (c) {
                    return c.teardown();
                });
 
                return all(l);
 
            },
 
            toString: function () {
                return '[object Altair]';
            }
 
        });
    });
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
 
 
 
 
 
 
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/**
 * What this class does differently than dojo/Deferred:
 *   * supports optional error logging suppression is reject()
 *   * step() alias to make for pretty codez
 *   * hasWaiting()
 */
define([
    "dojo/has",
    "dojo/_base/lang",
    "dojo/errors/CancelError",
    "dojo/promise/Promise",
    'altair/plugins/node!debug',
    "dojo/has!config-deferredInstrumentation?dojo/promise/instrumentation"
], function(has, lang, CancelError, Promise, debug, instrumentation){
 
    debug.enable('altair:Deferred');
    debug = debug('altair:Deferred');
 
    // module:
    //		dojo/Deferred
 
    var PROGRESS = 0,
        RESOLVED = 1,
        REJECTED = 2;
    var FULFILLED_ERROR_MESSAGE = "This deferred has already been fulfilled.";
 
    var freezeObject = Object.freeze || function(){};
 
    var signalWaiting = function(waiting, type, result, rejection, deferred, ignoreErrors){
        if(has("config-deferredInstrumentation")){
            if(!ignoreErrors && type === REJECTED && Deferred.instrumentRejected && waiting.length === 0){
                Deferred.instrumentRejected(result, false, rejection, deferred);
            }
        }
 
        for(var i = 0; i < waiting.length; i++){
            signalListener(waiting[i], type, result, rejection, ignoreErrors);
        }
    };
 
    var signalListener = function(listener, type, result, rejection, ignoreErrors){
        var func = listener[type];
        var deferred = listener.deferred;
        ignoreErrors = ignoreErrors || deferred.ignoreErrors;
        if(func){
            try{
 
                //if this is a deferredsignaler, pass through error status
                if(func.hasOwnProperty('__ignoreErrors')) {
                    func.__ignoreErrors = ignoreErrors;
                }
                var newResult = func(result);
                if(type === PROGRESS){
                    if(typeof newResult !== "undefined"){
                        signalDeferred(deferred, type, newResult);
                    }
                }else{
                    if(newResult && typeof newResult.then === "function"){
                        listener.cancel = newResult.cancel;
                        newResult.then(
                            // Only make resolvers if they're actually going to be used
                            makeDeferredSignaler(deferred, RESOLVED,ignoreErrors),
                            makeDeferredSignaler(deferred, REJECTED,ignoreErrors),
                            makeDeferredSignaler(deferred, PROGRESS,ignoreErrors));
                        return;
                    }
                    signalDeferred(deferred, RESOLVED, newResult, ignoreErrors);
                }
            }catch(error){
                debug(error);
                signalDeferred(deferred, REJECTED, error, ignoreErrors);
            }
        }else{
            signalDeferred(deferred, type, result, ignoreErrors);
        }
 
        if(has("config-deferredInstrumentation")){
            if(!ignoreErrors && type === REJECTED && Deferred.instrumentRejected){
                Deferred.instrumentRejected(result, !!func, rejection, deferred.promise);
            }
        }
    };
 
    var makeDeferredSignaler = function(deferred, type, ignoreErrors){
 
        var signaler = function(value){
            signalDeferred(deferred, type, value, signaler.__ignoreErrors);
        };
 
        signaler.__ignoreErrors = ignoreErrors;
 
        return signaler;
    };
 
    var signalDeferred = function(deferred, type, result, ignoreErrors){
        ignoreErrors = ignoreErrors || deferred.ignoreErrors;
        if(!deferred.isCanceled()){
            switch(type){
                case PROGRESS:
                    deferred.progress(result);
                    break;
                case RESOLVED:
                    deferred.resolve(result);
                    break;
                case REJECTED:
                    if(ignoreErrors) {
                        deferred.reject(result, false);
                    } else {
                        deferred.reject(result);
 
                    }
                    break;
            }
        }
    };
 
    var Deferred = function(canceler){
        // summary:
        //		Creates a new deferred. This API is preferred over
        //		`dojo/_base/Deferred`.
        // description:
        //		Creates a new deferred, as an abstraction over (primarily)
        //		asynchronous operations. The deferred is the private interface
        //		that should not be returned to calling code. That's what the
        //		`promise` is for. See `dojo/promise/Promise`.
        // canceler: Function?
        //		Will be invoked if the deferred is canceled. The canceler
        //		receives the reason the deferred was canceled as its argument.
        //		The deferred is rejected with its return value, or a new
        //		`dojo/errors/CancelError` instance.
 
        // promise: dojo/promise/Promise
        //		The public promise object that clients can add callbacks to.
        var promise = this.promise = new Promise();
 
        var deferred = this;
        var fulfilled, result, rejection;
        var canceled = false;
        var waiting = [];
 
        this.ignoreErrors = false;
 
        if(!this.ignoreErrors && !has("config-deferredInstrumentation") && Error.captureStackTrace){
            Error.captureStackTrace(deferred, Deferred);
            Error.captureStackTrace(promise, Deferred);
        }
 
        this.isResolved = promise.isResolved = function(){
            // summary:
            //		Checks whether the deferred has been resolved.
            // returns: Boolean
 
            return fulfilled === RESOLVED;
        };
 
        this.isRejected = promise.isRejected = function(){
            // summary:
            //		Checks whether the deferred has been rejected.
            // returns: Boolean
 
            return fulfilled === REJECTED;
        };
 
        this.isFulfilled = promise.isFulfilled = function(){
            // summary:
            //		Checks whether the deferred has been resolved or rejected.
            // returns: Boolean
 
            return !!fulfilled;
        };
 
        this.isCanceled = promise.isCanceled = function(){
            // summary:
            //		Checks whether the deferred has been canceled.
            // returns: Boolean
 
            return canceled;
        };
 
        this.progress = function(update, strict){
            // summary:
            //		Emit a progress update on the deferred.
            // description:
            //		Emit a progress update on the deferred. Progress updates
            //		can be used to communicate updates about the asynchronous
            //		operation before it has finished.
            // update: any
            //		The progress update. Passed to progbacks.
            // strict: Boolean?
            //		If strict, will throw an error if the deferred has already
            //		been fulfilled and consequently no progress can be emitted.
            // returns: dojo/promise/Promise
            //		Returns the original promise for the deferred.
 
            if(!fulfilled){
                signalWaiting(waiting, PROGRESS, update, null, deferred);
                return promise;
            }else if(strict === true){
                throw new Error(FULFILLED_ERROR_MESSAGE);
            }else{
                return promise;
            }
        };
 
        this.resolve = function(value, strict){
            // summary:
            //		Resolve the deferred.
            // description:
            //		Resolve the deferred, putting it in a success state.
            // value: any
            //		The result of the deferred. Passed to callbacks.
            // strict: Boolean?
            //		If strict, will throw an error if the deferred has already
            //		been fulfilled and consequently cannot be resolved.
            // returns: dojo/promise/Promise
            //		Returns the original promise for the deferred.
 
            if(!fulfilled){
                // Set fulfilled, store value. After signaling waiting listeners unset
                // waiting.
                signalWaiting(waiting, fulfilled = RESOLVED, result = value, null, deferred);
                waiting = null;
                return promise;
            }else if(strict === true){
                throw new Error(FULFILLED_ERROR_MESSAGE);
            }else{
                return promise;
            }
        };
 
        /**
         * Now passing strict as false with disable error reporting
         * @type {reject}
         */
        var reject = this.reject = function(error, strict){
            // summary:
            //		Reject the deferred.
            // description:
            //		Reject the deferred, putting it in an error state.
            // error: any
            //		The error result of the deferred. Passed to errbacks.
            // strict: Boolean?
            //		If strict, will throw an error if the deferred has already
            //		been fulfilled and consequently cannot be rejected.
            // returns: dojo/promise/Promise
            //		Returns the original promise for the deferred.
 
 
            if(!fulfilled){
                if(strict === false) {
                    this.ignoreErrors = true;
                    promise.ignoreErrors = true;
                }
                if(!this.ignoreErrors && has("config-deferredInstrumentation") && Error.captureStackTrace){
//                    error.__hasBeenLogged = true;
//                    console.error(error.stack || error);
                    Error.captureStackTrace(rejection = {}, reject);
                }
                signalWaiting(waiting, fulfilled = REJECTED, result = error, rejection, deferred, this.ignoreErrors);
                waiting = null;
                return promise;
            }else if(strict === true){
                throw new Error(FULFILLED_ERROR_MESSAGE);
            }else{
                return promise;
            }
        };
 
        this.hasWaiting = function () {
            return waiting.length > 0;
        };
 
        this.then = promise.then = function(callback, errback, progback){
            // summary:
            //		Add new callbacks to the deferred.
            // description:
            //		Add new callbacks to the deferred. Callbacks can be added
            //		before or after the deferred is fulfilled.
            // callback: Function?
            //		Callback to be invoked when the promise is resolved.
            //		Receives the resolution value.
            // errback: Function?
            //		Callback to be invoked when the promise is rejected.
            //		Receives the rejection error.
            // progback: Function?
            //		Callback to be invoked when the promise emits a progress
            //		update. Receives the progress update.
            // returns: dojo/promise/Promise
            //		Returns a new promise for the result of the callback(s).
            //		This can be used for chaining many asynchronous operations.
 
            var listener = [progback, callback, errback];
            // Ensure we cancel the promise we're waiting for, or if callback/errback
            // have returned a promise, cancel that one.
            listener.cancel = promise.cancel;
            listener.deferred = new Deferred(function(reason){
                // Check whether cancel is really available, returned promises are not
                // required to expose `cancel`
                return listener.cancel && listener.cancel(reason);
            });
 
 
            listener.deferred.ignoreErrors = this.ignoreErrors;
 
            if(fulfilled && !waiting){
                signalListener(listener, fulfilled, result, rejection);
            }else{
                waiting.push(listener);
            }
            return listener.deferred.promise;
        };
 
        this.otherwise = promise.step = function (errback, callback, progback) {
            return this.then(callback, errback, progback);
        };
 
        this.step = promise.step = function (progback, callback ,errback) {
            return this.then(callback, errback, progback);
        };
 
        this.always = function(callbackOrErrback){
            // summary:
            //		Add a callback to be invoked when the promise is resolved
            //		or rejected.
            // callbackOrErrback: Function?
            //		A function that is used both as a callback and errback.
            // returns: dojo/promise/Promise
            //		Returns a new promise for the result of the callback/errback.
 
            return this.then(callbackOrErrback, callbackOrErrback);
        };
 
 
        this.cancel = promise.cancel = function(reason, strict){
            // summary:
            //		Inform the deferred it may cancel its asynchronous operation.
            // description:
            //		Inform the deferred it may cancel its asynchronous operation.
            //		The deferred's (optional) canceler is invoked and the
            //		deferred will be left in a rejected state. Can affect other
            //		promises that originate with the same deferred.
            // reason: any
            //		A message that may be sent to the deferred's canceler,
            //		explaining why it's being canceled.
            // strict: Boolean?
            //		If strict, will throw an error if the deferred has already
            //		been fulfilled and consequently cannot be canceled.
            // returns: any
            //		Returns the rejection reason if the deferred was canceled
            //		normally.
 
            if(!fulfilled){
                // Cancel can be called even after the deferred is fulfilled
                if(canceler){
                    var returnedReason = canceler(reason);
                    reason = typeof returnedReason === "undefined" ? reason : returnedReason;
                }
                canceled = true;
                if(!fulfilled){
                    // Allow canceler to provide its own reason, but fall back to a CancelError
                    if(typeof reason === "undefined"){
                        reason = new CancelError();
                    }
                    reject(reason);
                    return reason;
                }else if(fulfilled === REJECTED && result === reason){
                    return reason;
                }
            }else if(strict === true){
                throw new Error(FULFILLED_ERROR_MESSAGE);
            }
        };
 
        freezeObject(promise);
    };
 
    Deferred.prototype.toString = function(){
        // returns: String
        //		Returns `[object Deferred]`.
 
        return "[object Deferred]";
    };
 
    if(instrumentation){
        instrumentation(Deferred);
    }
 
    return Deferred;
});
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/**
 * Altair's base LifeCycle mixin. Anytime your object has a 3 part lifecycle (setup, execute, teardown)
 * you should mixin this class. It returns dojo/Deferred's for each method for you, but chances are
 * you'll need to override one of these methods. Each one, by default, will return an auto-resolved
 * instance of a dojo/Deferred. That way usage is consistent, whether you override the method or not.
 *
 * Here is how I would implement my overridden startup()
 *
 * ...
 *
 * startup: function (options) {
 *
 *      //options are optional, fallback to the ones already set
 *      options = options || this.options;
 *
 *      //creating your own deferred will stop the auto-resolve behavior
 *      this.deferred = new Deferred();
 *
 *      //run your complicated, time consuming setup
 *      fs.someLongComplicatedAsyncProcess(this.hitch(function (results) {
 *
 *          //do something with your results
 *          this.results = results;
 *
 *          //always resolve and pass yourself.
 *          this.deferred.resolve(this);
 *
 *      }));
 *
 *      return this.inherited(arguments);
 *
 * }
 *
 * ...
 *
 * REMEMBER: the purpose of startup() is to to ensure execute() has everything it needs to do its job. Don't abuse startup().
 *
 */
define(['altair/facades/declare',
        './mixins/_DeferredMixin',
        'lodash'],
            function (declare,
                      _DeferredMixin) {
 
    "use strict";
 
 
    return declare([_DeferredMixin], {
 
        deferred:       null,
        options:        null,
 
        //deferred tracking
        _startupDeferred: null,
 
        constructor: function (options) {
            this.options = options;
        },
 
        /**
         * Put anything that needs to be done (configuring, setup, etc.) before your lifecycle is executed.
         *
         * Startup always returns an altair/Deferred. If one does not exist (meaning you did not set this.deferred = new Deferred
         * in your child class) then I will make one and resolve it immediately. This makes the operation synchronise,
         * but will allow us to always use the startup().then(... syntax.
         *
         * @param options simply copied to local this.options
         * @return {altair.Promise}
         */
        startup: function (options) {
 
            if(options) {
                this.options = _.clone(options);
            }
 
            if(!this.deferred) {
                this.deferred = new this.Deferred();
                this.deferred.resolve(this);
            }
 
            //remove the deferred after it's been resolved
            if(!this.deferred.always) {
 
                this.deferred.reject(new Error('Invalid deferred type, use altair/Deferred.'));
 
            } else {
 
                this.deferred.always(this._deferredAutoRemover(this.deferred));
            }
 
            //tracking
            this._startupDeferred = this.deferred;
 
            return this.deferred.promise || this.deferred;
 
        },
 
        /**
         * Mixin your async dependencies, for use during sartingy
         *
         * @param dependencies
         * @returns {*}
         */
        mixinDependencies: function (dependencies) {
 
            this.deferred = this.all(dependencies).then(function (deps) {
 
                declare.safeMixin(this, deps);
 
                return this;
 
            }.bind(this));
 
            return this.deferred;
 
        },
 
        /**
         * Do your work in here.
         *
         * @returns {altair.Promise}
         */
        execute: function () {
 
            //make sure startup deferred is still not active (can happen when someone goes life.startup().then(life.execute())
            //and deferreds are auto-resolved (which makes the whole process sync)
            if(this.deferred && this.deferred === this._startupDeferred) {
                this.deferred = null;
            }
 
            if(!this.deferred) {
                this.deferred = new this.Deferred();
                this.deferred.resolve(this);
            }
 
            //do not need the startup deferred again
            this._startupDeferred = null;
 
            //remove the deferred after it's been resolved
            this.deferred.always(this._deferredAutoRemover(this.deferred));
 
            return this.deferred.promise || this.deferred;
 
        },
 
        /**
         * Clean up so it's like you never existed.
         *
         * @returns {altair.Promise}
         */
        teardown: function () {
 
            if(!this.deferred) {
                this.deferred = new this.Deferred();
                this.deferred.resolve(this);
            }
 
            //remove the deferred after it's been resolved
            this.deferred.always(this._deferredAutoRemover(this.deferred));
 
            return this.deferred.promise || this.deferred;
 
        },
 
        _deferredAutoRemover: function(def) {
 
            var scope = this;
            return function () {
 
                setTimeout(function () {
 
                    if(scope.deferred === def && scope.deferred.isResolved()) {
                        scope.deferred = null;
                    }
 
                }, 0);
            };
        }
    });
});
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
 
 
 
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/**
 * Simple State Machine.
 */
define(['altair/facades/declare',
        'altair/facades/hitch',
        'altair/events/Emitter',
        'altair/events/Event',
        'altair/Deferred',
        'altair/facades/__',
        'altair/facades/sprintf',
        'lodash',
        'altair/plugins/node!debug'
        ],
    function (declare,
              hitch,
              Emitter,
              Event,
              Deferred,
              __,
              sprintf,
              _,
              debug) {
 
    debug = debug('altair/StateMachine');
 
 
    "use strict";
 
    return declare([Emitter], {
 
        state:  null, //the my current state
        states: null, //all our possible states
        repeat: false, //run forever?
 
        //statics
        _listenerMap: {
            'will-enter-state': 'onStateMachineWillEnter%s',
            'did-enter-state':  'onStateMachineDidEnter%s',
            'did-exit-state':   'onStateMachineDidExit%s'
        },
 
        constructor: function (options) {
 
            this.state  = options && _.has(options, 'state') ? options.state : this.state; //starting state is optional
            this.states = options.states;
 
            if(options && _.has(options, 'delegate')) {
                this.attachListeners(options.delegate);
            }
 
        },
 
        /**
         * Attach all our possible listeners to delegate depending on whether or not they exist
         *
         * @param delegate
         */
        attachListeners: function (delegate) {
 
            var listeners = [];
 
            //loop through each possible state
            this.states.forEach(hitch(this, function (state) {
 
                //then our listener map
                Object.keys(this._listenerMap).forEach(hitch(this, function (eventName) {
 
                    //construct the callbacks name
                    var methodName = this._stateAndEventNameToCallbackName(state, eventName);
 
                    //does the delegate have the name? if so, lets add a listener for it
                    if(delegate[methodName] !== undefined) {
                        listeners.push(this.on(eventName, hitch(delegate, methodName), { state: state }));
                    }
 
                }));
 
            }));
 
            return listeners;
        },
 
        /**
         * Start me over!
         *
         * @returns {altair.events.Emitter}
         */
        reset: function () {
            this.state = this.states[0];
            return this;
        },
 
        /**
         * Utility to make it a tad easier to set listeners
         *
         * @param state
         * @param eventName
         * @returns {*}
         * @private
         */
        _stateAndEventNameToCallbackName: function (state, eventName) {
            return sprintf(this._listenerMap[eventName], _.capitalize(state.replace(/-([a-z])/g, function (m, w) {
                return w.toUpperCase();
            })));
        },
 
        /**
         * Loops through every state, emitting all events along the way. If an event listener returns a deferred, we
         * wait until it is resolved before continuing. When we resolve our deferred, we will pass the return value
         * of the last state we transitionedTo
         *
         * @param options  - repeat: loop back on itself?
         * @returns {altair.Deferred}
         */
        execute: function (options) {
 
            //lastResponse is is in form [state, data]... if no state, we're done
            var d               = new Deferred(),
                state           = options && _.has(options, 'state') ? options.state : this.states[0], //optionally override starting state
                lastResponse    = [state, {}],
                fire            = hitch(this, function () {
 
                    if(!lastResponse[0]) {
                        d.resolve(lastResponse[1]);
                        return;
                    }
 
                    this.transitionTo(lastResponse[0], lastResponse[1], options).then(function (response) {
                        lastResponse = response;
                        fire();
                    }).otherwise(hitch(this, function (err) {
 
                        debug('state machine error in state: ' + state);
                        debug(err);
 
                        d.reject({
                            error: err,
                            state: state
                        });
                    }));
 
                });
 
            //repeat option passthrough
            if(_.has(options,'repeat')) {
                this.repeat = options.repeat;
            }
 
            fire();
 
            return d;
        },
 
        /**
         * Pass me a state and I'll let you know which state is next... if you on the last state, i'll pass back the first
         *
         * @param state
         * @param backToFirst
         *
         * @returns {*}
         */
        nextState: function (state, backToFirst) {
 
            var i = _.indexOf(this.states, state) + 1,
                next = '';
 
            if(i < this.states.length) {
                next = this.states[i];
            } else if(backToFirst === true){
                next = this.states[0];
            }
 
            return next;
        },
 
        /**
         * Same as above, but opposite order
         *
         * @param state
         * @param backToLast
         * @returns {string}
         */
        previousState: function (state, backToLast) {
 
            var i = _.indexOf(this.states, state) - 1,
                next = '';
 
            if(i >= 0) {
                next = this.states[i];
            } else if(backToLast === true){
                next = this.states[this.states.length-1];
            }
 
            return next;
        },
 
 
        /**
         * Transition to a particular state (which involves emitting all events that are the lifecycle of the state.
         *
         * @param state the state (must match something in this.states)
         * @param data object passed through to event (usually whatever was returned from previous state)
         */
        transitionTo: function (state, data, options) {
 
            this.state = state;//probably should wait until didEnterState before setting this, yeah?
 
            var dfd         = new Deferred(),
                eventData   = data,
                events      = Object.keys(this._listenerMap),
                lastResponse,
                nextState   = this.nextState(state, (options && _.has(options, 'repeat')) ? options.repeat : this.repeat),
                fire        = hitch(this, function (i) {
 
                    //are we on the last event?
                    if(i === events.length) {
                        dfd.resolve([nextState, lastResponse]);
                        return;
                    }
 
                    //make sure our event data is an object
                    if(!_.isObject(eventData)) {
                        eventData = {};
                    }
 
                    //make sure we at least have the state
                    eventData.state = state;
 
                    //emit this event
                    this.emit(events[i], eventData).then(hitch(this, function (e) {
 
                        //someone stopped the state machine
                        if(!e.active) {
                            this.repeat = false;
                            dfd.resolve([false, 'SIGABRT']);
                            return false;
                        }
 
                        var results = e.resultsRaw();
 
                        //get the results from the last event listener if any listeners are set
                        if(results.length > 0) {
 
                            lastResponse = results.pop();
 
                            //if lastResponse is in the form of [ nextState, { event: data } ]
                            //if so, halt the state machine and jump to that step immediately
                            if(_.isArray(lastResponse)) {
 
                                var _state = lastResponse[0];
 
                                if(_.indexOf(this.states, _state) === -1) {
                                    dfd.reject(new Error(__('State "%s" does not exist on this state machine.', _state)));
                                }
 
                                nextState       = _state;
                                eventData       = lastResponse[1];
                                lastResponse    = lastResponse[1];
 
                                dfd.resolve([nextState, lastResponse]);
                                return;
 
                            } else if(_.isObject(lastResponse)) {
                                eventData = lastResponse;
                            }
 
                        }
 
                        fire(++i);
 
                    })).otherwise(function (err) {
                        dfd.reject(err);
                    });
 
                });
 
            fire(0);
 
            return dfd;
 
        }
 
 
    });
});
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
 
 
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/**
 * Our simple test running. Works with doh/runner.
 */
define(['altair/facades/declare',
        'altair/Lifecycle',
        'altair/facades/hitch',
        'altair/facades/all',
        'altair/plugins/node!fs',
        'altair/plugins/node!debug',
        'altair/plugins/node!path',
        'doh/runner',
        'altair/facades/glob',
        'require'],
    function (declare,
              Lifecycle,
              hitch,
              all,
              fs,
              debug,
              path,
              doh,
              glob,
              require) {
 
 
        return declare('altair/TestRunner', [Lifecycle], {
 
            /**
             * @param options
             * options.paths - an array of paths whose contents are assumed to be tests
             *
             * @returns {*}
             */
            startup: function (options) {
 
                var list         = [],
                    _options = this.options || options;
 
                // No tests to run throw error
                if(!_options || !_options.glob) {
                    this.deferred.reject("You must pass glob option test runner to parse to look for tests.");
                    return;
                }
 
                doh.debug = console.log;
                doh.error = function (err) {
                    if(err.stack) {
                        console.error(err.stack || err);
                    } else {
                        console.log(err);
                    }
                };
 
 
                doh._handleFailure = function (groupName, fixture, e) {
 
                    // this.debug("FAILED test:", fixture.name);
                    // mostly borrowed from JUM
                    this._groups[groupName].failures++;
                    if(e instanceof this._AssertFailure){
                        this._failureCount++;
                        this.error(e.toString());
                    }else{
                        this._errorCount++;
                        this.error(e); // printing Error on IE9 (and other browsers?) yields "[Object Error]"
                    }
                    if(fixture.runTest["toSource"]){
                        var ss = fixture.runTest.toSource();
                        this.debug("\tERROR IN:\n\t\t", ss);
                    }else{
                        this.debug("\tERROR IN:\n\t\t", fixture.runTest);
                    }
                    if(e.rhinoException){
                        e.rhinoException.printStackTrace();
                    }else if(e.javaException){
                        e.javaException.printStackTrace();
                    }
                };
 
                this.deferred = glob(_options.glob.map(function (p) {
                    if (p[0] === '.') {
                        return path.join(process.cwd(), p);
                    } else {
                        return require.toUrl(p);
                    }
                }), _options.globOptions).then(hitch(this, function (files) {
 
                    list.concat(files.map(hitch(this, 'includeTest')));
                    return all(list);
 
                })).then(hitch(this, function () {
                    return this;
                }));
 
 
                return this.inherited(arguments);
            },
 
            execute: function () {
                this.deferred = new this.Deferred();
 
                doh._onEnd = hitch(this, function () {
                    if(doh._errorCount > 0) {
                        this.deferred.reject(doh._errorCount + ' tests failed.');
 
                    } else {
                        this.deferred.resolve();
 
                    }
 
                });
 
                doh.run();
 
                return this.inherited(arguments);
            },
 
 
            includeTest: function (path) {
                var deferred = new this.Deferred();
 
                require([path], function (t) {
                    if(!t) {
                        deferred.reject('including ' + path + ' failed');
 
                    } else {
                        deferred.resolve(t);
 
                    }
                });
 
                return deferred;
            }
 
        });
 
    });
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
 
 
 
 
 
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/**
 * Apollo is a unique ORM. It does not couple itself to any particular type of class, such as a data model or an entity.
 * Schemas in Apollo are strict... very strict. This is to ensure that any schema has everything it needs to be rendered
 * via a UI. Field options like "label" come in handy, even via cli and the "description"
 * attribute is a great place for user friendly documentation (that engineers will appreciate too).
 */
define(['dojo/_base/declare',
        'dojo/Deferred',
        'dojo/_base/lang',
        './Schema'
], function (declare,
             Deferred,
             lang,
             Schema) {
 
 
    return declare('apollo/Apollo', null, {
 
        propertyTypes: null,
 
        constructor: function (propertyTypes) {
            this.propertyTypes = {};
 
            if(propertyTypes) {
                this.addTypes(propertyTypes);
            }
 
        },
 
        /**
         * Add a new type of property
         * @param fieldType {apollo.propertyTypes._Base}
         * @returns {apollo.Apollo}
         */
        addType: function (propertyType) {
            this.propertyTypes[propertyType.key] = propertyType;
            return this;
        },
 
        /**
         * Add many property types at once.
         *
         * @param types
         */
        addTypes: function (types) {
            types.forEach(lang.hitch(this, function (type) {
                this.addType(type);
            }));
        },
 
        /**
         * Get you a property type by key
         *
         * @param type
         * @returns {*}
         */
        type: function (key) {
            return this.propertyTypes[key];
        },
 
        /**
         * Creates a schema based on the data you provide, but uses the field types that have been added to Apollo
         *
         * @param data
         * @returns {altair.io.core.lib.apollo.Schema}
         */
        createSchema: function (data) {
 
            var s = new Schema(data, this.propertyTypes);
 
            return s;
 
        }
 
 
    });
});
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
 
 
 
 
2
 
 
 
 
 
 
 
 
 
 
 
 
/**
 * A collection is a wrapper for an array of _HasSchemaMixin objects to allow for chaining calls.
 *
 *
 *
 */
define(['dojo/_base/declare',
        'dojo/Deferred',
        'dojo/_base/lang'
], function (declare, Deferred, lang) {
 
    return declare(null, {
 
 
 
    });
});
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/**
 * Apollo schemas are meant to be VERY lightweight.
 *
 * In altair
 *
 * var schema = this.nexus('cartridges/Apollo').createSchema({
 *  'properties' => {
 *      'fieldName' => {
 *          'type' => 'string',
 *          'options' => [
 *              'label'         => 'My cool field',
 *              'description'   => 'What the eff dude?',
 *              'required'      => true
 *          ]
 *      }
 * });
 *
 */
define(['dojo/_base/declare',
        'dojo/_base/lang',
        'dojo/Deferred',
        'dojo/promise/all',
        'lodash'
 
], function (declare, lang, Deferred, all, _) {
 
    "use strict";
 
    return declare(null, {
 
        _data:           null,
        _propertyTypes:   null,
        _optionsByField: null,
        _typeCache:      null,
 
        /**
         * Pass through straight config... assume its setup how we like it.
         *
         * @param schema
         */
        constructor: function (schema, propertyTypes) {
 
            if (!schema || !propertyTypes) {
                throw "You must pass a schema literal and an array of apollo/fieldtypes/_Base instances";
            }
 
            this._propertyTypes      = {};
            this._data              = schema;
            this._optionsByField    = {};
            this._typeCache         = {};
 
            if(!this._data.properties) {
                this._data.properties = {};
            }
 
            //make sure each property has a name in it as well
            _.each(this._data.properties, function (prop, name) {
                prop.name = name;
            });
 
            if (propertyTypes instanceof Array) {
 
                propertyTypes.forEach(lang.hitch(this, function (type) {
                    this._propertyTypes[type.key] = type;
                }));
 
            } else {
                this._propertyTypes = propertyTypes;
            }
 
 
        },
 
        /**
         * Does a schema have a field by this name?
         *
         * @param propertyName
         * @returns {boolean}
         */
        has: function (propertyName) {
            return (this._data.properties.hasOwnProperty(propertyName));
        },
 
        /**
         * Tells you the type of a particular property (firstName would return string)
         *
         * @param propertyName
         * @returns {string}
         */
        typeFor: function (propertyName) {
            return this._data.properties[propertyName].type;
        },
 
        /**
         * Set a single option for a property
         *
         * @param propertyName
         * @param optionName
         * @param optionValue
         * @returns {this}
         */
        setOptionFor: function (propertyName, optionName, optionValue) {
            if(!this.has(propertyName)) {
                throw new Error('No property named ' + propertyName + ' exists on schema ');
            }
            this._data.properties[propertyName].options[optionName] = optionValue;
            return this;
        },
 
        /**
         * A property by a particular name
         *
         * @param named
         * @returns {{}}
         */
        property: function (named) {
            return this._data.properties[named];
        },
 
        /**
         * I single option for a property
         *
         * @param propertyName
         * @param optionName
         * @returns {*}
         */
        optionFor: function (propertyName, optionName) {
 
            if(!_.has(this._data.properties, propertyName)) {
                throw new Error('no property called ' + propertyName + ' found on schema.');
            }
 
            return this._data.properties[propertyName].options[optionName];
        },
        /**
         * Get you all the options for this field mixed in with all options for the field type.
         *
         * @param propertyName
         * @param mixinAll optional
         * @returns {string} all options for that field type
         */
        optionsFor: function (propertyName, mixinAll) {
 
            if (propertyName in this._data.properties) {
 
                var property = this._data.properties[propertyName],
                    options = property.options;
 
                if (!options) {
                    throw new Error(propertyName + " has no options. add it to your schema");
                }
 
                //if we are doing a simple (lightweight) get of options
                if (mixinAll === false) {
                    return options;
                }
 
                if (!this._optionsByField[propertyName]) {
 
                    var type = this.propertyType(property.type);
                    this._optionsByField[propertyName] = type.normalizeOptions(options);
 
                }
 
 
            } else {
 
                throw new Error(propertyName + ' does not exist on ' + this.declaredClass);
            }
 
            return this._optionsByField[propertyName];
 
        },
 
        option: function (named) {
            return this._data[named];
        },
 
        get: function (named) {
            return this._data[named];
        },
 
        data: function () {
            return this._data;
        },
 
        primaryProperty: function () {
            return _.where(this._data.properties, { type: 'primary' }).pop();
        },
 
        /**
         * All the properties on this schema
         *
         * @returns {};
         */
        properties: function () {
            return this.option('properties');
        },
 
        /**
         * Gets all properties in this schema, but returns an array
         *
         * @returns {Array}
         */
        propertiesAsArray: function () {
 
            var properties = [];
 
            Object.keys(this._data.properties).forEach(lang.hitch(this, function (name) {
 
                var property = lang.mixin({}, this._data.properties[name], {
                    name: name
                });
 
                properties.push(property);
 
            }));
 
            return properties;
 
        },
 
        /**
         * Returns you a propertytype by a particular key, e.g. string, email, bool
         *
         * @param key
         * @returns {*}
         */
        propertyType: function (key) {
 
            if (!(key in this._propertyTypes)) {
                throw new Error('No property type of ' + key + ' found in schema.');
            }
 
            return this._propertyTypes[key];
 
        },
 
        /**
         * All property types
         *
         * @returns {*}
         */
        propertyTypes: function () {
            return this._propertyTypes;
        },
 
        /**
         * Apply a transformation strategy on many values at once (the keys of values must match a property in the schema)
         *
         * @param values
         * @param optionsByProperty
         * @param config
         * @returns {*}
         */
        applyOnValues: function (values, optionsByProperty, config) {
 
            var _obp     = optionsByProperty || {},
                _config  = config || {};
 
            _.each(values, function (value, name) {
                values[name] = this.applyOnProperty(_config.methods || ['toJsValue'], name, value, _obp[name], _config);
            }, this);
 
 
            return values;
 
        },
 
        /**
         * Tries all the methods passed on the property propertyType, first one wins.
         *
         * Example:
         *
         *  schema.applyOnProperty(['toSolrValue', 'toStringValue'], 'firstName', 'Taylo®™', { maxLength: 35 });
         *
         * @param named
         * @returns {*}
         */
        applyOnProperty: function (methodNames, propertyName, value, options, config) {
 
            if (!this._data.properties[propertyName]) {
                throw new Error('Property "' + propertyName + '" not found on ' + this + '.');
            }
 
            var property = this._data.properties[propertyName],
                type = property.type,
                _config = config || {},
                propertyType = this.propertyType(type),
                c,
                methodName;
 
            //by convention, these are null and will not be transformed
            if ((value === null || value === undefined) && _config.ignoreNull !== false) {
                return null;
            }
 
            //normalize options
            options = lang.mixin({}, this.optionsFor(propertyName), options || {});
 
            //normalize for many
            value = propertyType.normalizeMany(value, options, config);
 
            //invoke first method we find
            for (c = 0; c < methodNames.length; c++) {
 
                methodName = methodNames[c];
 
                if (_.isFunction(propertyType[methodName])) {
 
                    //make sure it's not an array when {{methodName}} is called
                    if (propertyType.makeValuesSingular) {
 
                        var wasArray = false;
 
                        if (value instanceof Array) {
 
                            wasArray = true;
 
                        } else {
 
                            value = [value];
 
                        }
 
                        var finalValue = [];
 
                        value.forEach(function (_value) {
                            if ((_value === null || _value === undefined) && _config.ignoreNull !== false) {
                                //skip because null
                            } else {
                                finalValue.push(propertyType[methodName](_value, options, config));
                            }
                        });
 
                        return wasArray && finalValue.length > 0 ? finalValue : finalValue.length > 0 ? finalValue[0] : null;
 
                    }
                    //we want the raw value passed to method name
                    else {
 
                        return propertyType[methodName](value, options, config);
 
                    }
                }
            }
 
            throw 'Could not find methods (' + methodNames.join(', ') + ') for property named "' + propertyName + '" of type "' + type + '".';
 
        },
 
        /**
         * Add a new property to this schema.
         *
         * @param name
         * @param type
         * @param options
         */
        append: function (name, type, options) {
            
            this._data.properties[name] = {
                type:       type,
                name:       name,
                options:    options
            };
 
            return this;
        },
 
        /**
         * Helpful printing
         * @returns {string}
         */
        toString: function () {
            return '[object Schema]';
        },
 
        /**
         * Validates all the values passed against our properties. Missing fields are also validaded with a value of null.
         *
         * schema().validate().then(... passs ...).otherwise(function (errs) {
         *      console.log('you have', errs.length, 'errors'); //outputs 'you have 6 errors'
         *      console.log('more details', errs.byProperty); //outputs `{ firstName: [...all errors...], email: [...all errors...] }
         * });
         *
         * If no error occured, it will not be include in errs.byProperty.
         *
         * @param values the keys should match properties on this schema
         * @param options { throwOnFirst: false, skipMissing: false } //should i return all errors, or just throw a new Error on first? - should i skip fields you did not pass?
         * @returns {*|Promise}
         */
        validate: function (values, options) {
 
            var everything  = {},
                errors      = [],
                errorsByProp = {},
                _options    = options || {},
                dfd         = new Deferred(),
                skipMissing  = _.has(_options, 'skipMissing') ? _options.skipMissing : false,
                _values     = values || {};
 
            //call validate on all properties
            _.each(this.properties(), function (prop, key) {
 
                //mantain keys for all validate() calls
                if(!skipMissing || _.has(values, key)) {
                    everything[key] = this.applyOnProperty(['validate'], key, _values[key] || null, {}, { ignoreNull: false });
                }
 
            }, this);
 
 
            //when all are done validating, check results for arrays (a result of true is pass, an array is fail)
            all(everything).then(function (results) {
 
                _.each(results, function (result, key) {
 
                    //anything with many: true will be
                    var many = this.optionFor(key, 'many'),
                        manyResults = many ? result : [result];
 
 
                    _.each(manyResults, function (result) {
 
                        //if the result of validate() is not true, it's an array of errors
                        if(result !== true) {
 
                            if(!_.isArray(result)) {
                                throw new Error('validate() for property type ' +  this.typeFor(key) + ' must return `true` or an array.');
                            }
 
                            if(_options.throwOnFirst) {
                                throw new Error(result[0]);
                            }
 
                            errors = errors.concat(result);
                            if (!errorsByProp[key]) {
                                errorsByProp[key] = [];
                            }
                            errorsByProp[key] = errorsByProp[key].concat(result);
                        }
 
                    });
 
                }, this);
 
                if( errors.length > 0 ) {
                    errors.byProperty = errorsByProp;
                    dfd.reject(errors);
                    return;
                }
 
                dfd.resolve(true);
 
 
            }.bind(this)).otherwise(function (err) {
                dfd.reject(err);
            });
 
            return dfd;
 
        }
 
    });
});
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
 
 
 
2
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/**
 * Apollo _HasSchemaMixin -> give any object you want a schema, it's powerful and stuff =)
 */
define(['dojo/_base/declare',
    'lodash',
    'dojo/Deferred',
    'dojo/promise/all',
    './Schema'
], function (declare,
             _,
             Deferred,
             all,
             Schema) {
 
    function capitalise(string) {
        return string.charAt(0).toUpperCase() + string.slice(1);
    }
 
 
    var _HasSchemaMixin = declare(null, {
 
        _schema: null,
        values: null,
 
        /**
         * Pass a schema if ya'nt
         *
         * @param schema
         */
        constructor: function (schema) {
 
            if (schema && schema.isInstanceOf && schema.isInstanceOf(Schema)) {
                this.setSchema(schema);
            }
 
        },
 
 
        toGetter: function(named) {
            return 'get' + capitalise(named);
        },
 
        toSetter: function(named) {
            return 'set' + capitalise(named);
        },
 
        /**
         * Will try and call an method to override this getter (getFieldName).
         *
         * @param name
         * @param defaultValue
         * @param options
         * @param config
         * @returns {*}
         */
        get: function (name, defaultValue, options, config) {
 
            var methodName = this.toGetter(name);
 
            if (typeof this[methodName] === 'function') {
                return this[methodName](defaultValue, options, config);
            }
 
            return this._get(name, defaultValue, options, config);
 
        },
 
        /**
         * Will try and call an overridden setter first, then
         *
         * @param name
         * @param value
         * @returns {apollo|_HasSchemaMixin}
         */
        set: function (name, value) {
 
            var methodName = this.toSetter(name),
                results;
 
            if (typeof this[methodName] === 'function') {
 
                results = this[methodName](value);
 
            } else {
 
                results = this._set(name, value);
            }
 
            return results;
        },
 
        /**
         * Mixes in only matching values, leaving the rest
         *
         * @param values
         * @returns {_HasSchemaMixin}
         */
        mixin: function (values, optionsByField, config) {
 
            var cleaned = {};
 
            _.each(values, function (value, name) {
                if (this.has(name)) {
 
                    if (config && config.methods) {
 
                        var options = optionsByField && optionsByField[name] || {};
 
                        //pass through old value
                        config.old = this.values[name];
 
                        //apply methods on value
                        cleaned[name] = this.schema().applyOnProperty(config.methods, name, value, options, config);
 
                    } else {
                        cleaned[name] = value;
                    }
                }
            }, this);
 
            if (config && config.methods) {
 
                return all(cleaned).then(function (values) {
 
                    _.each(values, function (value, name) {
                        this.set(name, value);
                    }, this);
 
                    return this;
 
                }.bind(this));
 
            } else {
 
                _.each(cleaned, function (value, name) {
                    this.set(name, value);
                }, this);
 
                return this;
 
            }
 
        },
 
        has: function (name) {
            return this.schema().has(name);
        },
 
        /**
         * Default setter, just sets values array
         *
         * @param name
         * @param value
         * @returns {apollo|_HasSchemaMixin}
         * @private
         */
        _set: function (name, value) {
 
            if (this.schema().has(name)) {
                this.values[name] = value;
 
            } else {
                throw new Error("No property called '" + name + "' exists on this " + this);
 
            }
 
            return this;
        },
 
        /**
         * Last resort getter. If you override a getter and still want access to the original value in the schema
         *
         * @param name
         * @param defaultValue
         * @param options
         * @param config
         * @returns {*}
         * @private
         */
        _get: function (name, defaultValue, options, config) {
 
            if (!_.has(this.values, name)) {
                throw new Error('No property ' + name + ' found on ' + this);
            }
 
            var value = this.schema().applyOnProperty((config && config.methods) ? config.methods : ['toJsValue'], name, this.values[name], options, config);
 
            if (value === null || value === undefined && !_.isUndefined(defaultValue)) {
                value = defaultValue;
 
            }
 
            return value;
        },
 
        /**
         * Set the schema to this object, then set default values to ourselves.
         *
         * @param schema
         * @returns {apollo|_HasSchemaMixin}
         */
        setSchema: function (schema) {
 
            this._schema = schema;
 
            if (!this.values) {
                this.values = {};
            }
 
            var properties = schema.properties();
 
            _.each(properties, function (value, name) {
 
                //only set values on ourselves that do not already exist
                //this is to ensure that values has a key for every property in the schema
                if (!( this.values.hasOwnProperty(name) )) {
                    var defaultValue = schema.optionsFor(name, false).default;
                    this.set(name, defaultValue);
                }
 
            }, this);
 
            return this;
 
        },
 
        /**
         * Returns you the schema attached to this object
         *
         * @returns {apollo.Schema}
         */
        schema: function () {
            return this._schema;
        },
 
        /**
         *
         * @returns {*}
         */
        getValues: function (optionsByProperty, config) {
 
            var values = {},
                _obp = optionsByProperty || {},
                _all = _obp['*'] || {},
                _config = config || {};
 
            _.each(this.schema().properties(), function (propConfig, name) {
 
                if (_obp) {
                    _obp[name] = _.defaults(_obp[name] || {}, _all);
                }
 
                var options = _.defaults(_obp[name] || {}, propConfig.options);
 
                values[name] = this.get(name, null, options, _config);
 
 
            }, this);
 
 
            return values;
 
        },
 
        primaryProperty: function () {
            return this.schema().primaryProperty();
        },
 
        primaryValue: function () {
            var prop = this.primaryProperty();
            return prop ? this.get(prop.name) : undefined;
        },
 
        /**
         * @TODO finish
         *
         * @returns {dojo.Deferred}
         */
        validate: function (options) {
 
            var schema = this.schema();
 
            if (!schema) {
                throw new Error('You can only validate objects that have a schema.');
            }
 
            return schema.validate(this.values, options).then(function () {
                return this;
            }.bind(this));
 
        }
 
    });
 
    return _HasSchemaMixin;
});
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
define([
	"dojo/dom", "dojo/dom-geometry", "dojo/dom-style",
	"dojo/_base/fx", "dojo/_base/lang", "dojo/query", "dojo/domReady", "dojo/sniff", "dojo/window",
	"doh/runner"
], function(dom, domGeom, domStyle, baseFx, lang, query, domReady, has, win, doh){
	doh.isBrowser= true;
	var topdog;
	try{
		topdog = (window.parent == window) || !Boolean(window.parent.doh);
	}catch(e){
		//can't access window.parent.doh, then consider ourselves as topdog
		topdog=true;
	}
	if(topdog){
		// we're the top-dog window.
 
		// borrowed from Dojo, etc.
		var byId = function(id){
			return document.getElementById(id);
		};
 
		var _addOnEvt = function( type,		// string
									refOrName,	// function or string
									scope){		// object, defaults is window
 
			if(!scope){ scope = window; }
 
			var funcRef = refOrName;
			if(typeof refOrName == "string"){
				funcRef = scope[refOrName];
			}
			var enclosedFunc = function(){ return funcRef.apply(scope, arguments); };
 
			if(domReady && type == "load"){
				domReady(enclosedFunc);
			}else{
				if(window["attachEvent"]){
					window.attachEvent("on"+type, enclosedFunc);
				}else if(window["addEventListener"]){
					window.addEventListener(type, enclosedFunc, false);
				}else if(document["addEventListener"]){
					document.addEventListener(type, enclosedFunc, false);
				}
			}
		};
 
		//
		// Over-ride or implement base runner.js-provided methods
		//
		var escapeXml = function(str){
			// summary:
			//		Adds escape sequences for special characters in XML: &<>"'
			//		Optionally skips escapes for single quotes
			return str.replace(/&/gm, "&amp;").replace(/</gm, "&lt;").replace(/>/gm, "&gt;").replace(/"/gm, "&quot;"); // string
		};
 
		var formatTime = function(n){
			switch(true){
				case n<1000: //<1s
					return n+"ms";
				case n<60000: //<1m
					return Math.round(n/100)/10+"s";
				case n<3600000: //<1h
					return Math.round(n/6000)/10+"m";
				default: //>1h
					return Math.round(n/360000)/10+"h";
			}
		};
 
		var _logBacklog = [], _loggedMsgLen = 0;
		var sendToLogPane = function(args, skip){
			var msg = "";
			for(var x = 0; x < args.length; x++){
				msg += " " + args[x];
			}
 
			msg = escapeXml(msg);
 
			// workarounds for IE. Wheeee!!!
			msg = msg.replace("\t", "&nbsp;&nbsp;&nbsp;&nbsp;")
				.replace(" ", "&nbsp;")
				.replace("\n", "<br>&nbsp;");
			if(!byId("logBody")){
				_logBacklog.push(msg);
				return;
			}else if(_logBacklog.length && !skip){
				var tm;
				while((tm = _logBacklog.shift())){
					sendToLogPane(tm, true);
				}
			}
			var logBody = byId("logBody");
			var tn = document.createElement("div");
			tn.innerHTML = msg;
			//tn.id="logmsg_"+logBody.childNodes.length;
			logBody.appendChild(tn);
			_loggedMsgLen++;
		};
 
		var findTarget = function(n){
			while(n && !n.getAttribute('_target')){
				n = n.parentNode;
				if(!n.getAttribute){
					n = null;
				}
			}
			return n;
		};
 
		doh._jumpToLog = function(e){
			//console.log(e);
 
			var node = findTarget(e?e.target:window.event.srcElement);
			if(!node){
				return;
			}
			var _t = Number(node.getAttribute('_target'));
			var lb = byId("logBody");
			if(_t>=lb.childNodes.length){
				return;
			}
			var t = lb.childNodes[_t];
			t.scrollIntoView();
			if(domStyle && baseFx){
				//t.parentNode.parentNode is <div class="tabBody">, only it has a explicitly set background-color,
				//all children of it are transparent
				var bgColor = domStyle.get(t.parentNode.parentNode,'backgroundColor');
				//node.parentNode is the tr which has background-color set explicitly
				var hicolor = domStyle.get(node.parentNode,'backgroundColor');
				var unhilight = baseFx.animateProperty({
					node: t,
					duration: 500,
					properties:
					{
						backgroundColor: { start: hicolor, end: bgColor }
					},
					onEnd: function(){
						t.style.backgroundColor="";
					}
				});
				var hilight = baseFx.animateProperty({
					node: t,
					duration: 500,
					properties:
					{
						backgroundColor: { start: bgColor, end: hicolor }
					},
					onEnd: function(){
						unhilight.play();
					}
				});
				hilight.play();
			}
		};
 
		doh._jumpToSuite = function(e){
			var node = findTarget(e ? e.target : window.event.srcElement);
			if(!node){
				return;
			}
			var _g = node.getAttribute('_target');
			var gn = getGroupNode(_g);
			if(!gn){
				return;
			}
			gn.scrollIntoView();
		};
 
		doh._init = (function(oi){
			return function(){
				var lb = byId("logBody");
				if(lb){
					// clear the console before each run
					while(lb.firstChild){
						lb.removeChild(lb.firstChild);
					}
					_loggedMsgLen = 0;
				}
				this._totalTime = 0;
				this._suiteCount = 0;
				oi.apply(doh, arguments);
			}
		})(doh._init);
 
		doh._setupGroupForRun = (function(os){
			//overload _setupGroupForRun to record which log line to jump to when a suite is clicked
			return function(groupName){
				var tg = doh._groups[groupName];
				doh._curTestCount = tg.length;
				doh._curGroupCount = 1;
				var gn = getGroupNode(groupName);
				if(gn){
					//two lines will be added, scroll the second line into view
					gn.getElementsByTagName("td")[2].setAttribute('_target',_loggedMsgLen+1);
				}
				os.apply(doh,arguments);
			}
		})(doh._setupGroupForRun);
 
		var originalDohReport= doh._report;
		doh._report = function(){
			var tb = byId("testList");
			if(tb){
				var tfoots=tb.getElementsByTagName('tfoot');
				if(tfoots.length){
					tb.removeChild(tfoots[0]);
				}
				var foot = tb.createTFoot();
				var row = foot.insertRow(-1);
				row.className = 'inProgress';
				var cell=row.insertCell(-1);
				cell.colSpan=2;
				cell.innerHTML="Result";
				cell = row.insertCell(-1);
				cell.innerHTML=this._testCount+" tests in "+this._groupCount+" groups /<span class='failure'>"+this._errorCount+"</span> errors, <span class='failure'>"+this._failureCount+"</span> failures";
				cell.setAttribute('_target',_loggedMsgLen+1);
				row.insertCell(-1).innerHTML=formatTime(doh._totalTime);
			}
 
			//This location can do the final performance rendering for the results
			//of any performance tests.
 
			if(doh.perfTestResults){
				require(["dojox/math/stats", "dojox/charting/DataChart", "dojox/charting/plot2d/Scatter", "dojox/charting/plot2d/Lines", "dojo/data/ItemFileReadStore"],
						function(stats, DataChart, Scatter, Lines, ItemFileReadStore){
					lang.mixin(doh, stats);
 
					var plotResults = function(div, name, dataArray) {
						// Performance report generating functions!
						var median = doh.median(dataArray);
						var medarray = [];
 
						var i;
						for(i = 0; i < dataArray.length; i++){
							medarray.push(median);
						}
 
						var data = {
							label: "name",
							items: [
								{name: name, trials: dataArray},
								{name: "Median", trials: medarray}
							]
						};
						var ifs = new ItemFileReadStore({data: data});
 
						var min = Math.floor(doh.min(dataArray));
						var max = Math.ceil(doh.max(dataArray));
						var step = (max - min)/10;
 
						//Lets try to pad out the bottom and top a bit
						//Then recalc the step.
						if(min > 0){
							min = min - step;
							if(min < 0){
								min = 0;
							}
							min = Math.floor(min);
						}
						if(max > 0){
							max = max + step;
							max = Math.ceil(max);
						}
						step = (max - min)/10;
 
						var chart = new DataChart(div, {
							type: Lines,
							displayRange: dataArray.length,
							xaxis: {min: 1, max: dataArray.length, majorTickStep: Math.ceil((dataArray.length - 1)/10), htmlLabels: false},
							yaxis: {min: min, max: max, majorTickStep: step, vertical: true, htmlLabels: false}
						});
						chart.setStore(ifs, {name:"*"}, "trials");
					};
 
					try{
						var g;
						var pBody = byId("perfTestsBody");
						var chartsToRender = [];
						// store analytics for reading later
						// keyed on test group name, each value is in turn an object keyed on test name
						doh.perfTestAnalytics={};
						doh.showPerfTestsPage();
						for(g in doh.perfTestResults){
							doh.perfTestAnalytics[g] = {};
							var grp = doh.perfTestResults[g];
							var hdr = document.createElement("h1");
							hdr.appendChild(document.createTextNode("Group: " + g));
							pBody.appendChild(hdr);
							var ind = document.createElement("blockquote");
							pBody.appendChild(ind);
							var f;
							for(f in grp){
								var fResults = grp[f];
								if(!fResults){ continue; }
								var fhdr = document.createElement("h3");
								fhdr.appendChild(document.createTextNode("TEST: " + f));
								fhdr.style.textDecoration = "underline";
								ind.appendChild(fhdr);
								var div = document.createElement("div");
								ind.appendChild(div);
 
								//Figure out the basic info
								var results = "<b>TRIAL SIZE: </b>"	 + fResults.trials[0].testIterations + " iterations<br>" +
									"<b>NUMBER OF TRIALS: </b>" + fResults.trials.length + "<br>";
 
								//Figure out the average test pass cost.
								var i;
								var iAvgArray = [];
								var tAvgArray = [];
								for(i = 0; i < fResults.trials.length; i++){
									iAvgArray.push(fResults.trials[i].average);
									tAvgArray.push(fResults.trials[i].executionTime);
								}
								var analytics = doh.perfTestAnalytics[g][f] = {
									averageTrialExecutionTime: doh.mean(tAvgArray),
									maxTestIterationTime: doh.max(iAvgArray),
									minTestIterationTime: doh.min(iAvgArray),
									averageTestIterationTime: doh.mean(iAvgArray),
									medianTestIterationTime: doh.median(iAvgArray),
									varianceTestIterationTime: doh.variance(iAvgArray),
									standardDeviationTestIterationTime: doh.sd(iAvgArray)
								};
								results += "<b>AVERAGE TRIAL EXECUTION TIME: </b>" + analytics.averageTrialExecutionTime.toFixed(10) + "ms.<br>";
								results += "<b>MAXIMUM TEST ITERATION TIME: </b>" + analytics.maxTestIterationTime.toFixed(10) + "ms.<br>";
								results += "<b>MINIMUM TEST ITERATION TIME: </b>" + analytics.minTestIterationTime.toFixed(10) + "ms.<br>";
								results += "<b>AVERAGE TEST ITERATION TIME: </b>" + analytics.averageTestIterationTime.toFixed(10) + "ms.<br>";
								results += "<b>MEDIAN TEST ITERATION TIME: </b>" + analytics.medianTestIterationTime.toFixed(10) + "ms.<br>";
								results += "<b>VARIANCE TEST ITERATION TIME: </b>" + analytics.varianceTestIterationTime.toFixed(10) + "ms.<br>";
								results += "<b>STANDARD DEVIATION ON TEST ITERATION TIME: </b>" +analytics.standardDeviationTestIterationTime.toFixed(10) + "ms.<br>";
 
								//Okay, attach it all in.
								div.innerHTML = results;
 
								div = document.createElement("div");
								div.innerHTML = "<h3>Average Test Execution Time (in milliseconds, with median line)</h3>";
								ind.appendChild(div);
								div = document.createElement("div");
								domStyle.set(div, "width", "600px");
								domStyle.set(div, "height", "250px");
								ind.appendChild(div);
								chartsToRender.push({
									div: div,
									title: "Average Test Execution Time",
									data: iAvgArray
								});
 
								div = document.createElement("div");
								div.innerHTML = "<h3>Average Trial Execution Time (in milliseconds, with median line)</h3>";
								ind.appendChild(div);
								div = document.createElement("div");
								domStyle.set(div, "width", "600px");
								domStyle.set(div, "height", "250px");
								ind.appendChild(div);
								chartsToRender.push({
									div: div,
									title: "Average Trial Execution Time",
									data: tAvgArray
								});
							}
						}
 
						//Lazy-render these to give the browser time and not appear locked.
						var delayedRenders = function() {
							if(chartsToRender.length){
								var chartData = chartsToRender.shift();
								plotResults(chartData.div, chartData.title, chartData.data);
							}
							setTimeout(delayedRenders, 50);
						};
						setTimeout(delayedRenders, 150);
					}catch(e){
						doh.debug(e);
					}
				});
			}
			originalDohReport.apply(doh,arguments);
		};
 
 
		doh.error = undefined;
		if(this["opera"] && opera.postError){
			doh.debug = function(){
				var msg = "";
				for(var x=0; x<arguments.length; x++){
					msg += " "+arguments[x];
				}
				sendToLogPane([msg]);
				opera.postError("DEBUG:"+msg);
			}
		}else if(window["console"]){
			if(console.error){
				doh.error = function(){
					sendToLogPane.call(window, arguments);
					console.error(Array.prototype.join.call(arguments, " "))
				};
			}
			if(console.debug){
				doh.debug = function(){
					sendToLogPane.call(window, arguments);
					console.debug(Array.prototype.join.call(arguments, " "))
				};
			}else if(console.info){
				doh.debug = function(){
					sendToLogPane.call(window, arguments);
					console.info(Array.prototype.join.call(arguments, " "))
				};
			}else{
				doh.debug = function(){
					sendToLogPane.call(window, arguments);
					console.log("DEBUG:"+ Array.prototype.join.call(arguments, " "));
				};
			}
		}else{
			doh.debug = function(){
				sendToLogPane.call(window, arguments);
			}
		}
		doh.error = doh.error || doh.debug;
		var loaded = false;
		var groupTemplate = null;
		var testTemplate = null;
 
		var groupNodes = {};
 
		var _groupTogglers = {};
 
		var _getGroupToggler = function(group, toggle){
			if(_groupTogglers[group]){ return _groupTogglers[group]; }
			var rolledUp = true;
			return (_groupTogglers[group] = function(evt, forceOpen){
				var nodes = groupNodes[group].__items;
				var x;
				if(rolledUp||forceOpen){
					rolledUp = false;
					for(x=0; x<nodes.length; x++){
						nodes[x].style.display = "";
					}
					toggle.innerHTML = "&#9660;";
				}else{
					rolledUp = true;
					for(x=0; x<nodes.length; x++){
						nodes[x].style.display = "none";
					}
					toggle.innerHTML = "&#9658;";
				}
			});
		};
 
		var addGroupToList = function(group){
			if(!byId("testList")){
				return;
			}
			var tb = byId("testList").tBodies[0];
			var tg = groupTemplate.cloneNode(true);
			var tds = tg.getElementsByTagName("td");
			var toggle = tds[0];
			toggle.onclick = _getGroupToggler(group, toggle);
			var cb = tds[1].getElementsByTagName("input")[0];
			cb.group = group;
			cb.onclick = function(){
				doh._groups[group].skip = (!this.checked);
			};
			tds[2].innerHTML = "<div class='testGroupName'>" + group + "</div><div style='width:0;'>&nbsp;</div>";
			tds[3].innerHTML = "";
 
			tb.appendChild(tg);
			return tg;
		};
 
		var addFixtureToList = function(group, fixture){
			if(!testTemplate){
				return;
			}
			var cgn = groupNodes[group];
			if(!cgn["__items"]){
				cgn.__items = [];
			}
			var tn = testTemplate.cloneNode(true);
			var tds = tn.getElementsByTagName("td");
 
			tds[2].innerHTML = fixture.name;
			tds[3].innerHTML = "";
 
			var nn = (cgn.__lastFixture || cgn.__groupNode).nextSibling;
			if(nn){
				nn.parentNode.insertBefore(tn, nn);
			}else{
				cgn.__groupNode.parentNode.appendChild(tn);
			}
			// FIXME: need to make group display toggleable!!
			tn.style.display = "none";
			cgn.__items.push(tn);
			return (cgn.__lastFixture = tn);
		};
 
		var getFixtureNode = function(group, fixture){
			if(groupNodes[group]){
				return groupNodes[group][fixture.name];
			}
			return null;
		};
 
		var getGroupNode = function(group){
			if(groupNodes[group]){
				return groupNodes[group].__groupNode;
			}
			return null;
		};
 
		var updateBacklog = [];
		doh._updateTestList = function(group, fixture, unwindingBacklog){
			if(!loaded){
				if(group && fixture){
					updateBacklog.push([group, fixture]);
				}
				return;
			}else if(updateBacklog.length && !unwindingBacklog){
				var tr;
				while((tr = updateBacklog.shift())){
					doh._updateTestList(tr[0], tr[1], true);
				}
			}
			if(group && fixture){
				if(!groupNodes[group]){
					groupNodes[group] = {
						"__groupNode": addGroupToList(group)
					};
				}
				if(!groupNodes[group][fixture.name]){
					groupNodes[group][fixture.name] = addFixtureToList(group, fixture)
				}
			}
		};
 
		doh._testRegistered = doh._updateTestList;
 
		doh._groupStarted = function(group){
			if(this._suiteCount == 0){
				this._runedSuite = 0;
				this._currentGlobalProgressBarWidth = 0;
				this._suiteCount = this._testCount;
			}
			// console.debug("_groupStarted", group);
			if(doh._inGroup != group){
				doh._groupTotalTime = 0;
				doh._runed = 0;
				doh._inGroup = group;
				this._runedSuite++;
			}
			var gn = getGroupNode(group);
			if(gn){
				gn.className = "inProgress";
			}
		};
 
		doh._groupFinished = function(group, success){
			// console.debug("_groupFinished", group);
			var gn = getGroupNode(group);
			if(gn && doh._inGroup == group){
				doh._totalTime += doh._groupTotalTime;
				gn.getElementsByTagName("td")[3].innerHTML = formatTime(doh._groupTotalTime);
				gn.getElementsByTagName("td")[2].lastChild.className = "";
				doh._inGroup = null;
				//doh._runedSuite++;
				var failure = doh._updateGlobalProgressBar(this._runedSuite / this._groupCount, success, group);
				gn.className = failure ? "failure" : "success";
				//doh._runedSuite--;
				doh._currentGlobalProgressBarWidth = parseInt(this._runedSuite / this._groupCount * 10000) / 100;
				//byId("progressOuter").style.width = parseInt(this._runedSuite/this._suiteCount*100)+"%";
			}
			if(doh._inGroup == group){
				this.debug("Total time for GROUP \"", group, "\" is ", formatTime(doh._groupTotalTime));
			}
		};
 
		doh._testStarted = function(group, fixture){
			// console.debug("_testStarted", group, fixture.name);
			var fn = getFixtureNode(group, fixture);
			if(fn){
				fn.className = "inProgress";
			}
		};
 
		var _nameTimes = {};
		var _playSound = function(name){
			if(byId("hiddenAudio") && byId("audio") && byId("audio").checked){
				// console.debug("playing:", name);
				var nt = _nameTimes[name];
				// only play sounds once every second or so
				if((!nt) || (((new Date) - nt) > 700)){
					_nameTimes[name] = new Date();
					var tc = document.createElement("span");
					byId("hiddenAudio").appendChild(tc);
					tc.innerHTML = '<embed src="_sounds/' + name + '.wav" autostart="true" loop="false" hidden="true" width="1" height="1"></embed>';
				}
			}
		};
 
		doh._updateGlobalProgressBar = function(p, success, group){
			var outerContainer = byId("progressOuter");
 
			var gdiv = outerContainer.childNodes[doh._runedSuite - 1];
			if(!gdiv){
				gdiv = document.createElement('div');
				outerContainer.appendChild(gdiv);
				gdiv.className = 'success';
				gdiv.setAttribute('_target', group);
			}
			if(!success && !gdiv._failure){
				gdiv._failure = true;
				gdiv.className = 'failure';
				if(group){
					gdiv.setAttribute('title', 'failed group ' + group);
				}
			}
			var tp = parseInt(p * 10000) / 100;
			gdiv.style.width = (tp - doh._currentGlobalProgressBarWidth) + "%";
			return gdiv._failure;
		};
		doh._testFinished = function(group, fixture, success){
			var fn = getFixtureNode(group, fixture);
			var elapsed = fixture.endTime-fixture.startTime;
			var gn;
			if(fn){
				fn.getElementsByTagName("td")[3].innerHTML = formatTime(elapsed);
				fn.className = (success) ? "success" : "failure";
				fn.getElementsByTagName("td")[2].setAttribute('_target', _loggedMsgLen);
				if(!success){
					_playSound("doh");
					gn = getGroupNode(group);
					if(gn){
						gn.className = "failure";
						_getGroupToggler(group)(null, true);
					}
				}
			}
			if(doh._inGroup == group){
				gn = getGroupNode(group);
				doh._runed++;
				if(gn && doh._curTestCount){
					var p = doh._runed/doh._curTestCount;
					var groupfail = this._updateGlobalProgressBar((doh._runedSuite+p-1)/doh._groupCount,success,group);
 
					var pbar = gn.getElementsByTagName("td")[2].lastChild;
					pbar.className = groupfail?"failure":"success";
					pbar.style.width = parseInt(p*100)+"%";
					gn.getElementsByTagName("td")[3].innerHTML = parseInt(p*10000)/100+"%";
				}
			}
			this._groupTotalTime += elapsed;
			this.debug((success ? "PASSED" : "FAILED"), "test:", fixture.name, elapsed, 'ms');
		};
 
		doh._registerUrl = function(group, url, timeout, type, dohArgs){
			group= group || url;
			this._registerTest(group, {
				name: url,
				setUp: function(){
					doh.currentGroupName = group;
					doh.currentGroup = this;
					doh.currentUrl = url;
					doh.dohArgs = dohArgs;
					this.d = new doh.Deferred();
					doh.currentTestDeferred = this.d;
					doh.showTestPage();
					byId("testBody").src = url;
				},
				timeout: timeout||10000, // 10s
				// timeout: timeout||1000, // 10s
				runTest: function(){
					// FIXME: implement calling into the url's groups here!!
					return this.d;
				},
				tearDown: function(){
					doh.currentGroupName = null;
					doh.currentGroup = null;
					doh.currentTestDeferred = null;
					doh.currentUrl = null;
					// this.d.errback(false);
					// byId("testBody").src = "about:blank";
					doh.showLogPage();
				}
			}, type);
		};
 
		//
		// Utility code for runner.html
		//
		// var isSafari = navigator.appVersion.indexOf("Safari") >= 0;
		var tabzidx = 1;
		var _showTab = function(toShow, toHide){
			// FIXME: I don't like hiding things this way.
			var i;
			for(i = 0; i < toHide.length; i++){
				var node = byId(toHide[i]);
				if(node){
					node.style.display = "none";
				}
			}
			toShow = byId(toShow);
			if(toShow){
				toShow.style.display = "";
				toShow.style.zIndex = ++tabzidx;
			}
		};
 
		doh.showTestPage = function(){
			_showTab("testBody", ["logBody", "perfTestsBody"]);
		};
 
		doh.showLogPage = function(){
			_showTab("logBody", ["testBody", "perfTestsBody"]);
		};
 
		doh.showPerfTestsPage = function(){
			_showTab("perfTestsBody", ["testBody", "logBody"]);
		};
 
		var runAll = true;
		doh.toggleRunAll = function(){
			// would be easier w/ query...sigh
			runAll = !runAll;
			if(!byId("testList")){
				return;
			}
			var tb = byId("testList").tBodies[0];
			var inputs = tb.getElementsByTagName("input");
			var x = 0;
			var tn;
			while((tn = inputs[x++])){
				tn.checked = runAll;
				doh._groups[tn.group].skip = (!runAll);
			}
		};
 
		var listHeightTimer = null;
		var setListHeight = function(){
			if(listHeightTimer){
				clearTimeout(listHeightTimer);
			}
			var tl = byId("testList");
			if(!tl){
				return;
			}
			listHeightTimer = setTimeout(function(){
				tl.style.display = "none";
				tl.style.display = "";
 
			}, 10);
		};
 
		_addOnEvt("resize", setListHeight);
		_addOnEvt("load", setListHeight);
		_addOnEvt("load", function(){
			if(loaded){ return; }
			loaded = true;
			groupTemplate = byId("groupTemplate");
			if(!groupTemplate){
				// make sure we've got an amenable DOM structure
				return;
			}
			groupTemplate.parentNode.removeChild(groupTemplate);
			groupTemplate.style.display = "";
			testTemplate = byId("testTemplate");
			testTemplate.parentNode.removeChild(testTemplate);
			testTemplate.style.display = "";
			doh._updateTestList();
		});
 
		_addOnEvt("load",
			function(){
				// let robot code run if it gets to this first
				var __onEnd = doh._onEnd;
				doh._onEnd = function(){
					__onEnd.apply(doh, arguments);
					if(doh._failureCount == 0){
						doh.debug("WOOHOO!!");
						_playSound("woohoo");
					}else{
						console.debug("doh._failureCount:", doh._failureCount);
					}
					if(byId("play")){
						toggleRunning();
					}
				};
				if(!byId("play")){
					// make sure we've got an amenable DOM structure
					return;
				}
				var isRunning = false;
				var toggleRunning = function(){
					// ugg, this would be so much better w/ dojo.query()
					if(isRunning){
						byId("play").style.display = byId("pausedMsg").style.display = "";
						byId("playingMsg").style.display = byId("pause").style.display = "none";
						isRunning = false;
					}else{
						byId("play").style.display = byId("pausedMsg").style.display = "none";
						byId("playingMsg").style.display = byId("pause").style.display = "";
						isRunning = true;
					}
				};
				doh.run = (function(oldRun){
					return function(){
						if(!doh._currentGroup){
							toggleRunning();
						}
						return oldRun.apply(doh, arguments);
					}
				})(doh.run);
				var btns = byId("toggleButtons").getElementsByTagName("span");
				var node; var idx=0;
				while((node=btns[idx++])){
					node.onclick = toggleRunning;
				}
			}
		);
	}else{
		// we're in an iframe environment. Time to mix it up a bit.
 
		var _doh = window.parent.doh;
		var _thisGroup = _doh.currentGroupName;
		var _thisUrl = _doh.currentUrl;
		if(_thisGroup){
			doh._onEnd = function(){
				_doh._errorCount += doh._errorCount;
				_doh._failureCount += doh._failureCount;
				_doh._testCount += doh._testCount;
				// should we be really adding raw group counts?
				//_doh._groupCount += doh._groupCount;
				_doh.currentTestDeferred.callback(true);
			};
			doh._testRegistered = function(group, fixture){
				fixture.name = _thisUrl+"::"+arguments[0]+"::"+fixture.name;
				_doh._updateTestList(_thisGroup, fixture);
			};
			doh.debug = lang.hitch(_doh, "debug");
			doh.error = lang.hitch(_doh, "error");
			doh.registerUrl = lang.hitch(_doh, "registerUrl");
			doh._testStarted = function(group, fixture){
				_doh._testStarted(_thisGroup, fixture);
			};
			doh._testFinished = function(g, f, s){
				_doh._testFinished(_thisGroup, f, s);
 
				//Okay, there may be performance info we need to filter back
				//to the parent, so do that here.
				if(doh.perfTestResults){
					try{
						var gName = g.toString();
						var localFName = f.name;
						while(localFName.indexOf("::") >= 0){
							localFName = localFName.substring(localFName.indexOf("::") + 2, localFName.length);
						}
						if(!_doh.perfTestResults){
							_doh.perfTestResults = {};
						}
						if(!_doh.perfTestResults[gName]){
							_doh.perfTestResults[gName] = {};
						}
						_doh.perfTestResults[gName][f.name] = doh.perfTestResults[gName][localFName];
					}catch (e){
						doh.debug(e);
					}
				}
			};
			doh._groupStarted = function(){
				if(!this._setParent){
					_doh._curTestCount = this._testCount;
					_doh._curGroupCount = this._groupCount;
					this._setParent = true;
				}
			};
			doh._report = function(){
			};
		}
	}
 
	var fixHeight = doh._fixHeight = function(){
		// IE9 doesn't give test iframe height because no nodes have an explicit pixel height!
		// Give outer table a pixel height.
		if(has("ie")){
			var headerHeight = 0;
			var rows = query('#testLayout > tbody > tr');
			for(var i = 0; i < rows.length-1; i++){
				headerHeight += domGeom.position(rows[i]).h;
			}
			try{
				// we subtract the headerHeight from the window height because the table row containing the tests is height:100% so they will stretch the table to the intended height.
				dom.byId('testLayout').style.height = (win.getBox().h - headerHeight)+"px";
			}catch(e){
				// An obscure race condition when you load the runner in IE from the command line causes the window reported height to be 0.
				// Try to recover after the window finishes rendering.
				setTimeout(function(){ fixHeight(); },0);
			}
		}
	};
 
	return doh;
});
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
define(["doh/runner", "require", "dojo/_base/config"], function(doh, require, config){
	/*=====
	return {
		// summary:
		//		Module for running DOH tests in node (as opposed to a browser).
		//		Augments return value from doh/runner.
	};
	=====*/
 
	doh.debug= console.log;
	doh.error= console.log;
 
	// Override the doh._report method to make it quit with an
	// appropriate exit code in case of test failures.
	var oldReport = doh._report;
	doh._report = function(){
		oldReport.apply(doh, arguments);
		if(this._failureCount > 0 || this._errorCount > 0){
			process.exit(1);
		}
	};
 
	console.log("\n"+doh._line);
	console.log("The Dojo Unit Test Harness, $Rev: e6490e5 $");
	console.log("Copyright (c) 2011, The Dojo Foundation, All Rights Reserved");
	console.log("Running with node.js");
	for (var tests= [], args= config["commandLineArgs"], i= 0, arg; i<args.length; i++) {
		arg= args[i];
		if (arg.length==2 && arg[0]=="test") {
			var test= arg[1];
			console.log("loading test " + test);
			tests.push(test);
		}
	}
	console.log(doh._line, "\n");
 
	require(tests, function() {
		doh.run();
	});
});
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
2
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
(function(){
	var
		boot =
			// zero to many scripts to load a configuration and/or loader.
			// i.e. path-to-util/doh/runner.html?boots=path-to/config.js,path-to/require.js
			["../../dojo/dojo.js"],
 
		standardDojoBoot = boot,
 
		test =
			// zero to many AMD modules and/or URLs to load; provided by csv URL query parameter="test"
			// For example, the URL...
			//
			//		 path-to-util/doh/runner.html?test=doh/selfTest,my/path/test.js
			//
			// ...will load...
			//
			//	 * the AMD module doh/selfTest
			//	 * the plain old Javascript resource my/path/test.js
			//
			["dojo/tests/module"],
 
		paths = 
			// zero to many path items to pass to the AMD loader; provided by semicolon separated values 
			// for URL query parameter="paths"; each path item has the form <from-path>,<to-path>
			// i.e. path-to-util/doh/runner.html?paths=my/from/path,my/to/path;my/from/path2,my/to/path2
			{},
			
		dohPlugins = 
			// Semicolon separated list of files to load before the tests.
			// Idea is to override aspects of DOH for reporting purposes.
			"",
 
		breakOnError = 
			// boolean; instructs doh to call the debugger upon a test failures; this can be helpful when
			// trying to isolate exactly where the test failed
			false,
 
		async = 
			// boolean; config require.async==true before loading boot; this will have the effect of making
			// version 1.7+ dojo bootstrap/loader operating in async mode
			false,
 
		sandbox = 
			// boolean; use a loader configuration that sandboxes the dojo and dojox objects used by doh
			false,
 
		trim = function(text){
			if(text instanceof Array){
				for (var result= [], i= 0; i<text.length; i++) {
					result.push(trim(text[i]));
				}
				return result;
			}else{
				return text.match(/[^\s]*/)[0]; 
			}
		};
 
		qstr = window.location.search.substr(1);
 
	if(qstr.length){
		for(var qparts = qstr.split("&"), x = 0; x < qparts.length; x++){
			var tp = qparts[x].split("="), name=tp[0], value=(tp[1]||"").replace(/[<>"':\(\)]/g, ""); // replace() to avoid XSS attack
			//Avoid URLs that use the same protocol but on other domains, for security reasons.
			if (value.indexOf("//") === 0 || value.indexOf("\\\\") === 0) {
				throw "Insupported URL";
			}
			switch(name){
				// Note:
				//	 * dojoUrl is deprecated, and is a synonym for boot
				//	 * testUrl is deprecated, and is a synonym for test
				//	 * testModule is deprecated, and is a synonym for test (dots are automatically replaced with slashes)
				//	 * registerModulePath is deprecated, and is a synonym for paths
				case "boot":
				case "dojoUrl":
					boot= trim(value.split(","));
					break;
 
				case "test":
				case "testUrl":
					test= trim(value.split(","));
					break;
 
				case "testModule":
					test= trim(value.replace(/\./g, "/").split(","));
					break;
 
				// registerModulePath is deprecated; use "paths"
				case "registerModulePath":
				case "paths":
					for(var path, modules = value.split(";"), i= 0; i<modules.length; i++){
						path= modules[i].split(",");
						paths[trim(path[0])]= trim(path[1]);
					}
					break;
 
				case "breakOnError":
					breakOnError= true;
					break;
 
				case "sandbox":
					sandbox= true;
					break;
 
				case "async":
					async= true;
					break;
				case "dohPlugins":
					dohPlugins=value.split(";");
					break;
			}
		}
	}
 
	var config;
	if(sandbox){
		// configure the loader assuming the dojo loader; of course the injected boot(s) can override this config
		config= {
			paths: paths,
			// this config uses the dojo loader's scoping features to sandbox the version of dojo used by doh
			packages: [{
				name: 'doh',
				location: '../util/doh',
				// here's the magic...every time doh asks for a "dojo" module, it gets mapped to a "dohDojo"
				// module; same goes for dojox/dohDojox since doh uses dojox
				packageMap: {dojo:"dohDojo", dojox:"dohDojox"}
			},{
				// now define the dohDojo package...
				name: 'dohDojo',
				location: '../dojo',
				packageMap: {dojo: "dohDojo", dojox: "dohDojox"}
			},{
				// and the dohDojox package...
				name: 'dohDojox',
				location: '../dojox',
				// and dojox uses dojo...that is, dohDojox...which must be mapped to dohDojo in the context of dohDojox
				packageMap: {dojo: "dohDojo", dojox: "dohDojox"}
			}],
			
			// next, we need to preposition a special configuration for dohDojo
			cache: {
				"dohDojo*_base/config": function(){
					define([], {
						// this configuration keeps dojo, dijit, and dojox out of the global space
						scopeMap: [["dojo", "dohDojo"], ["dijit", "dohDijit"], ["dojox", "dohDojox"]],
						isDebug: true,
						noGlobals: true
					});
				}
			},
 
			// control the loader; don't boot global dojo, doh will ask for dojo itself
			has: {
				"dojo-sniff": 0,
				"dojo-loader": 1,
				"dojo-boot": 0,
				"dojo-test-sniff": 1
			},
 
			// no sniffing; therefore, set the baseUrl
			baseUrl: "../../dojo",
 
			deps: ["dohDojo/domReady", "doh"],
 
			callback: function(domReady, doh){
				domReady(function(){
					doh._fixHeight();
					doh.breakOnError= breakOnError;
					require(test, function(){
						doh.run();
					});
				});
			},
 
			async: async
		};
	}else{
		config= {
			paths: paths,
			deps: ["dojo/domReady", "doh"],
			callback: function(domReady, doh){
				domReady(function(){
					doh._fixHeight();
					doh.breakOnError= breakOnError;
					require(test, function(){
						doh.run();
					});
				});
			},
			async: async,
			isDebug: 1
		};
	}
	
	// load all of the dohPlugins
	if(dohPlugins){
		var i = 0;
		for(i = 0; i < dohPlugins.length; i++){
			config.deps.push(dohPlugins[i]);
		}
	}
	
	require = config;
 
	// now script inject any boots
	for(var e, i = 0; i < boot.length; i++) {
		if(boot[i]){
			e = document.createElement("script");
			e.type = "text/javascript";
			e.src = boot[i];
			e.charset = "utf-8";
			document.getElementsByTagName("head")[0].appendChild(e);
		}
	}
})();
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
define(["doh/runner", "require", "dojo/_base/config"], function(doh, require, config){
	/*=====
	 return {
	 // summary:
	 //		Module for running DOH tests in rhino (as opposed to a browser).
	 //		Augments return value from doh/runner.
	 };
	 =====*/
 
	doh.debug= print;
	doh.error= print;
 
	// Override the doh._report method to make it quit with an
	// appropriate exit code in case of test failures.
	var oldReport = doh._report;
	doh._report = function(){
		oldReport.apply(doh, arguments);
		if(this._failureCount > 0 || this._errorCount > 0){
			quit(1);
		}
	};
 
	print("\n"+doh._line);
	print("The Dojo Unit Test Harness, $Rev: e6490e5 $");
	print("Copyright (c) 2011, The Dojo Foundation, All Rights Reserved");
	for (var tests= [], args= config["commandLineArgs"], i= 0, arg; i<args.length; i++) {
		arg= (args[i]+"").split("=");
		if (arg.length==2 && arg[0]=="test") {
			var test= arg[1];
			print("loading test " + test);
			tests.push(test);
		}
	}
	print(doh._line, "\n");
 
	require(tests, function() {
		doh.run();
	});
});
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
1
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
var testResourceRe = /^doh\/tests/,
	list = {
		"doh/doh.profile": 1,
		"doh/package.json": 1,
		"doh/tests": 1,
		"doh/_parseURLargs": 1
	},
	copyOnly = function(mid){
		return (mid in list);
	};
 
var profile = {
	resourceTags: {
		test: function(filename, mid){
			return testResourceRe.test(mid);
		},
 
		copyOnly: function(filename, mid){
			return copyOnly(mid);
		},
 
		amd: function(filename, mid){
			return !testResourceRe.test(mid) && !copyOnly(mid) && /\.js$/.test(filename);
		}
	}
};
 
 

1
2
3
4
5
6
7
8
9
2
 
 
 
 
 
 
 
 
define([
	"doh/runner",
	"dojo/has!host-browser?doh/_browserRunner",
	"dojo/has!host-node?doh/_nodeRunner",
	"dojo/has!host-rhino?doh/_rhinoRunner"], function(doh) {
	return doh;
});
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
define([
	"doh/_browserRunner", "require",
	"dojo/aspect", "dojo/Deferred", "dojo/dom-class", "dojo/dom-construct", "dojo/dom-geometry", "dojo/_base/lang", "dojo/ready",
	"dojo/_base/unload", "dojo/when", "dojo/_base/window", "dojo/sniff", "dojo/has", "dojo/has!android?doh/plugins/android-webdriver-robot"
], function(doh, require, aspect, Deferred, domClass, construct, geom, lang, ready, unload, when, win, sniff, has, webdriver){
 
// loading state
var _robot = null;
 
var isSecure = (function(){
	var key = Math.random();
	return function(fcn){
		return key;
	};
})();
 
var _keyPress = function(/*Number*/ charCode, /*Number*/ keyCode, /*Boolean*/ alt, /*Boolean*/ ctrl, /*Boolean*/ shift, /*Boolean*/ meta, /*Integer?*/ delay, /*Boolean*/ async){
	// internal function to type one non-modifier key
 
	// typecasting Numbers helps Sun's IE plugin lookup methods that take int arguments
 
	// otherwise JS will send a double and Sun will complain
	_robot.typeKey(isSecure(), Number(charCode), Number(keyCode), Boolean(alt), Boolean(ctrl), Boolean(shift), Boolean(meta), Number(delay||0), Boolean(async||false));
};
 
// Queue of pending actions plus the currently executing action registered via sequence().
// Each action is a function that either:
//		1. does a setTimeout()
//		2. calls java Robot (mouse movement, typing a single letter, etc.)
//		3. executes user defined function (for when app called sequence() directly).
// Each function can return a Promise, or just a plain value if it executes synchronously.
var seqPromise;
aspect.before(doh, "_runFixture", function(){
	// At the start of each new test fixture, clear any leftover queued actions from the previous test fixture.
	// This will happen when the previous test throws an error, or times out.
	var _seqPromise = seqPromise;
	// need setTimeout to avoid false error; seqPromise from passing test is not fulfilled until after this execution trace finishes!
	// really we should not have both `seqPromise` here and `var d = new doh.Deferred()` in the test
	setTimeout(function(){
		if(_seqPromise && !_seqPromise.isFulfilled()){
			_seqPromise.cancel(new Error("new test starting, cancelling pending & in-progress queued events from previous test")); 
		}
	},0);
	seqPromise = new Deferred();
	seqPromise.resolve(true);
});
 
// Previous mouse position (from most recent mouseMoveTo() command)
var lastMouse = {x: 5, y: 5};
 
// For 2.0, remove code to set doh.robot global.
var robot = doh.robot = {
	_robotLoaded: true,
	_robotInitialized: false,
	// prime the event pump for fast browsers like Google Chrome - it's so fast, it doesn't stop to listen for keypresses!
	_spaceReceived: false,
	_primePump: false,
 
	_killApplet: function(){}, // overridden by Robot.html
 
	killRobot: function(){
		if(robot._robotLoaded){
			robot._robotLoaded = false;
			domClass.remove(document.documentElement, "dohRobot");
			robot._killApplet();
		}
	},
 
	// Robot init methods
 
	// controls access to doh.run
	// basically, doh.run takes two calls to start the robot:
	// one (or more after the robot loads) from the test page
	// one from either the applet or an error condition
	_runsemaphore: {
		lock: ["lock"],
		unlock: function(){
			try{
				return this.lock.shift();
			}catch(e){
				return null;
			}
		}
	},
 
	startRobot: function(){
		//startRobot should be called to initialize the robot (after the java applet is loaded).
		//one good place to do this is in a dojo.addOnLoad handler. This function will be called
		//automatically if it is not already called when doh.run() is invoked.
		if(!this._robotInitialized){
			this._robotInitialized = true;
			// if the iframe requested the applet and got a 404, then _robot is obviously unavailable
			// at least run the non-robot tests!
			if(robot._appletDead){
				robot._onKeyboard();
			}else{
				_robot._callLoaded(isSecure());
			}
		}
 
		// When robot finishes initializing it types a key, firing the _onKeyboard() listener, which calls _run(),
		// which resolves this Deferred.
		return this._started;
	},
 
	// _loaded: Deferred
	//		Deferred that resolves when the _initRobot() has been called.
	//		Note to be confused with dojo/robotx.js, which defines initRobot() without an underscore
	_loaded: new doh.Deferred(),
 
	_initRobot: function(r){
		// called from Robot
		// Robot calls _initRobot in its startup sequence
 
		// Prevent rerunning the whole test (see #8958 for details)
		if(doh._initRobotCalled){ return; }
		doh._initRobotCalled = true;
 
		// add dohRobot class to HTML element so tests can use that in CSS rules if desired
		domClass.add(document.documentElement, "dohRobot");
		window.scrollTo(0, 0);
//		document.documentElement.scrollTop = document.documentElement.scrollLeft = 0;
		_robot = r;
		_robot._setKey(isSecure());
		this._loaded.resolve(true);
	},
 
	// _started: Deferred
	//		Deferred that resolves when startRobot() has signaled completing by typing on the keyboard,
	//		which in turn calls _run().
	_started: new doh.Deferred(),
 
	// some utility functions to help the iframe use private variables
	_run: function(frame){
		// called after the robot has been able to type on the keyboard, indicating that it's started
		frame.style.visibility = "hidden";
		this._started.resolve(true);
	},
 
	_initKeyboard: function(){
		_robot._initKeyboard(isSecure());
	},
 
	_onKeyboard: function(){
		// replaced by iframe when applet present.
		// remote robots don't have frames so pass a mock frame.
		this._run({style:{visibility:""}});
	},
 
	_initWheel: function(){
		_robot._initWheel(isSecure());
	},
 
	_setDocumentBounds: function(docScreenX, docScreenY){
		var robotView = document.getElementById("dohrobotview");
		_robot.setDocumentBounds(isSecure(), Number(docScreenX), Number(docScreenY), Number(robotView.offsetLeft), Number(robotView.offsetTop));
	},
 
	_notified: function(keystring){
		_robot._notified(isSecure(), keystring);
	},
 
	// if the applet is 404 or cert is denied, this becomes true and kills tests
	_appletDead: false,
 
	_assertRobot: function(){
		// make sure the applet is there and cert accepted
		// otherwise, skip the test requesting the robot action
		if(robot._appletDead){ throw new Error('robot not available; skipping test.'); }
	},
 
	_mouseMove: function(/*Number*/ x, /*Number*/ y, /*Boolean*/ absolute, /*Integer?*/ duration){
		// This function is no longer used, but left for back-compat
		if(absolute){
			var scroll = {y: (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0),
			x: (window.pageXOffset || geom.fixIeBiDiScrollLeft(document.documentElement.scrollLeft) || document.body.scrollLeft || 0)};
			y -= scroll.y;
			x -= scroll.x;
		}
		_robot.moveMouse(isSecure(), Number(x), Number(y), Number(0), Number(duration||100));
	},
 
	// Main robot API
	sequence: function(/*Function*/ f, /*Integer?*/ delay, /*Integer?*/ duration){
		// summary:
		//		Defer an action by adding it to the robot's incrementally delayed queue of actions to execute.
		// f:
		//		A function containing actions you want to defer.  It can return a Promise
		//		to delay further actions.
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
		// duration:
		//		Delay to wait after firing.
 
		function waitFunc(ms){
			// Returns a function that returns a Promise that fires after ms milliseconds.
			return function(){
				var timer, d;
				d = new Deferred(function(){ clearTimeout(timer); });
				timer = setTimeout(function(){ d.resolve(true); }, ms);
				return d;
			};
		}
 
		// Queue action to run specified function, plus optional "wait" actions for delay and duration.
		if(delay){ seqPromise = seqPromise.then(waitFunc(delay)); }
		seqPromise = seqPromise.then(f);
		if(duration){ seqPromise = seqPromise.then(waitFunc(duration)); }
	},
 
	typeKeys: function(/*String|Number*/ chars, /*Integer?*/ delay, /*Integer?*/ duration){
		// summary:
		//		Types a string of characters in order, or types a dojo.keys.* constant.
		// description:
		//		Types a string of characters in order, or types a dojo.keys.* constant.
		// example:
		// |	robot.typeKeys("dijit.ed", 500);
		// chars:
		//		String of characters to type, or a dojo.keys.* constant
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
		// duration:
		//		Time, in milliseconds, to spend pressing all of the keys.
		//		The default is (string length)*50 ms.
 
		this._assertRobot();
		var isNum = typeof(chars) == Number;
		duration = duration||(isNum?50: chars.length*50);
		if(isNum){
			this.sequence(lang.partial(_keyPress, chars, chars, false, false, false, false, 0, 0),
				delay, duration);
		}else{
			for(var i = 0; i < chars.length; i++){
				this.sequence(lang.partial(_keyPress, chars.charCodeAt(i), 0, false, false, false, false, 0, 0),
					i == 0 ? delay : 0, Math.max(Math.ceil(duration/chars.length), 0));
			}
		}
	},
 
	keyPress: function(/*Integer*/ charOrCode, /*Integer?*/ delay, /*Object*/ modifiers, /*Boolean*/ asynchronous){
		// summary:
		//		Types a key combination, like SHIFT-TAB.
		// description:
		//		Types a key combination, like SHIFT-TAB.
		// example:
		//		to press shift-tab immediately, call robot.keyPress(dojo.keys.TAB, 0, {shift: true})
		// charOrCode:
		//		char/JS keyCode/dojo.keys.* constant for the key you want to press
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
		// modifiers:
		//		JSON object that represents all of the modifier keys being pressed.
		//		It takes the following Boolean attributes:
		//
		//		- shift
		//		- alt
		//		- ctrl
		//		- meta
		// asynchronous:
		//		If true, the delay happens asynchronously and immediately, outside of the browser's JavaScript thread and any previous calls.
		//		This is useful for interacting with the browser's modal dialogs.
 
		this._assertRobot();
		if(!modifiers){
			modifiers = {alt:false, ctrl:false, shift:false, meta:false};
		}else{
			// normalize modifiers
			var attrs = ["alt", "ctrl", "shift", "meta"];
			for(var i = 0; i<attrs.length; i++){
				if(!modifiers[attrs[i]]){
					modifiers[attrs[i]] = false;
				}
			}
		}
		var isChar = typeof(charOrCode)=="string";
		if(asynchronous){
			_keyPress(isChar?charOrCode.charCodeAt(0):0, isChar?0:charOrCode, modifiers.alt, modifiers.ctrl, modifiers.shift, modifiers.meta, delay, true);
			return;
		}
		this.sequence(function(){
			_keyPress(isChar?charOrCode.charCodeAt(0):0, isChar?0:charOrCode, modifiers.alt, modifiers.ctrl, modifiers.shift, modifiers.meta, 0);
		}, delay);
	},
 
	keyDown: function(/*Integer*/ charOrCode, /*Integer?*/ delay){
		// summary:
		//		Holds down a single key, like SHIFT or 'a'.
		// description:
		//		Holds down a single key, like SHIFT or 'a'.
		// example:
		//		to hold down the 'a' key immediately, call robot.keyDown('a')
		// charOrCode:
		//		char/JS keyCode/dojo.keys.* constant for the key you want to hold down
		//		Warning: holding down a shifted key, like 'A', can have unpredictable results.
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
 
		this._assertRobot();
		this.sequence(function(){
			var isChar = typeof(charOrCode)=="string";
			_robot.downKey(isSecure(), isChar?charOrCode:0, isChar?0:charOrCode, 0);
		}, delay);
	},
 
	keyUp: function(/*Integer*/ charOrCode, /*Integer?*/ delay){
		// summary:
		//		Releases a single key, like SHIFT or 'a'.
		// description:
		//		Releases a single key, like SHIFT or 'a'.
		// example:
		//		to release the 'a' key immediately, call robot.keyUp('a')
		// charOrCode:
		//		char/JS keyCode/dojo.keys.* constant for the key you want to release
		//		Warning: releasing a shifted key, like 'A', can have unpredictable results.
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
 
		this._assertRobot();
		this.sequence(function(){
			var isChar=typeof(charOrCode)=="string";
			_robot.upKey(isSecure(), isChar?charOrCode:0, isChar?0:charOrCode, 0);
		}, delay);
	},
 
 
	mouseClick: function(/*Object*/ buttons, /*Integer?*/ delay){
		// summary:
		//		Convenience function to do a press/release.
		//		See robot.mousePress for more info.
		// description:
		//		Convenience function to do a press/release.
		//		See robot.mousePress for more info.
 
		this._assertRobot();
		robot.mousePress(buttons, delay);
		robot.mouseRelease(buttons, 1);
	},
 
	mousePress: function(/*Object*/ buttons, /*Integer?*/ delay){
		// summary:
		//		Presses mouse buttons.
		// description:
		//		Presses the mouse buttons you pass as true.
		//		Example: to press the left mouse button, pass {left: true}.
		//		Mouse buttons you don't specify keep their previous pressed state.
		// buttons:
		//		JSON object that represents all of the mouse buttons being pressed.
		//		It takes the following Boolean attributes:
		//
		//		- left
		//		- middle
		//		- right
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
 
		this._assertRobot();
		if(!buttons){ return; }
		this.sequence(function(){
			var attrs = ["left", "middle", "right"];
			for(var i = 0; i<attrs.length; i++){
				if(!buttons[attrs[i]]){
					buttons[attrs[i]] = false;
				}
			}
			_robot.pressMouse(isSecure(), Boolean(buttons.left), Boolean(buttons.middle), Boolean(buttons.right), Number(0));
		}, delay);
	},
 
	mouseMoveTo: function(/*Object*/ point, /*Integer?*/ delay, /*Integer?*/ duration, /*Boolean*/ absolute){
		// summary:
		//		Move the mouse from the current position to the specified point.
		//		Delays reading contents point until queued command starts running.
		//		See mouseMove() for details.
		// point: Object
		//		x, y position relative to viewport, or if absolute == true, to document
 
		this._assertRobot();
		duration = duration||100;
 
		// Calculate number of mouse movements we will do, based on specified duration.
		// IE6-8 timers have a granularity of 15ms, so only do one mouse move every 15ms
		var steps = duration<=1 ? 1 : // duration==1 -> user wants to jump the mouse
			(duration/15)|1; // |1 to ensure an odd # of intermediate steps for sensible interpolation
		var stepDuration = Math.floor(duration/steps);
 
		// Starting and ending points of the mouse movement.
		var start, end;
 
		this.sequence(function(){
			// This runs right before we start moving the mouse.   At this time (but not before), point is guaranteed
			// to be filled w/the correct data.   So set start and end points for the movement of the mouse.
			start = lastMouse;
			if(absolute){
				// Adjust end to be relative to viewport
				var scroll = {y: (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0),
					x: (window.pageXOffset || geom.fixIeBiDiScrollLeft(document.documentElement.scrollLeft) || document.body.scrollLeft || 0)};
				end = { y: point.y - scroll.y, x: point.x - scroll.x };
			}else{
				end = point;
			}
			//console.log("mouseMoveTo() start, going from (", lastMouse.x, lastMouse.y, "), (", end.x, end.y, "), delay = " +
			//	delay + ", duration = " + duration);
		}, delay || 0);
 
		// Function to positions the mouse along the line from start to end at the idx'th position (from 0 .. steps)
		function step(idx){
			function easeInOutQuad(/*Number*/ t, /*Number*/ b, /*Number*/ c, /*Number*/ d){
				t /= d / 2;
				if(t < 1)
					return Math.round(c / 2 * t * t + b);
				t--;
				return Math.round(-c / 2 * (t * (t - 2) - 1) + b);
			}
 
			var x = idx == steps ? end.x : easeInOutQuad(idx, start.x, end.x - start.x, steps),
				y = idx == steps ? end.y : easeInOutQuad(idx, start.y, end.y - start.y, steps);
 
			// If same position as the last time, don't bother calling java robot.
			if(x == lastMouse.x && y == lastMouse.y){ return true; }
 
			_robot.moveMouse(isSecure(), Number(x), Number(y), Number(0), Number(1));
			lastMouse = {x: x, y: y};
		}
 
		// Schedule mouse moves from beginning to end of line.
		// Start from t=1 because there's no need to move the mouse to where it already is
		for (var t = 1; t <= steps; t++){
			// Use lang.partial() to lock in value of t before the t++
			this.sequence(lang.partial(step, t), 0, stepDuration);
		}
	},
 
	mouseMove: function(/*Number*/ x, /*Number*/ y, /*Integer?*/ delay, /*Integer?*/ duration, /*Boolean*/ absolute){
		// summary:
		//		Moves the mouse to the specified x,y offset relative to the viewport.
		// x:
		//		x offset relative to the viewport, in pixels, to move the mouse.
		// y:
		//		y offset relative to the viewport, in pixels, to move the mouse.
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
		// duration:
		//		Approximate time Robot will spend moving the mouse
		//		The default is 100ms. This also affects how many mousemove events will
		//		be generated, which is the log of the duration.
		// absolute:
		//		Boolean indicating whether the x and y values are absolute coordinates.
		//		If false, then mouseMove expects that the x,y will be relative to the window. (clientX/Y)
		//		If true, then mouseMove expects that the x,y will be absolute. (pageX/Y)
 
		this.mouseMoveTo({x: x, y: y}, delay, duration, absolute);
	},
 
	mouseRelease: function(/*Object*/ buttons, /*Integer?*/ delay){
		// summary:
		//		Releases mouse buttons.
		// description:
		//		Releases the mouse buttons you pass as true.
		//		Example: to release the left mouse button, pass {left: true}.
		//		Mouse buttons you don't specify keep their previous pressed state.
		//		See robot.mousePress for more info.
 
		this._assertRobot();
		if(!buttons){ return; }
		this.sequence(function(){
			var attrs = ["left", "middle", "right"];
			for(var i = 0; i<attrs.length; i++){
				if(!buttons[attrs[i]]){
					buttons[attrs[i]] = false;
				}
			}
			_robot.releaseMouse(isSecure(), Boolean(buttons.left), Boolean(buttons.middle), Boolean(buttons.right), Number(0));
		}, delay);
	},
 
	// mouseWheelSize: Integer value that determines the amount of wheel motion per unit
	mouseWheelSize: 1,
 
	mouseWheel: function(/*Number*/ wheelAmt, /*Integer?*/ delay, /*Integer?*/ duration){
		// summary:
		//		Spins the mouse wheel.
		// description:
		//		Spins the wheel wheelAmt "notches."
		//		Negative wheelAmt scrolls up/away from the user.
		//		Positive wheelAmt scrolls down/toward the user.
		//		Note: this will all happen in one event.
		//		Warning: the size of one mouse wheel notch is an OS setting.
		//		You can access this size from robot.mouseWheelSize
		// wheelAmt:
		//		Number of notches to spin the wheel.
		//		Negative wheelAmt scrolls up/away from the user.
		//		Positive wheelAmt scrolls down/toward the user.
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		//			robot.mouseClick({left: true}, 100) // first call; wait 100ms
		//			robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
		// duration:
		//		Approximate time Robot will spend moving the mouse
		//		By default, the Robot will wheel the mouse as fast as possible.
 
		this._assertRobot();
		if(!wheelAmt){ return; }
		this.sequence(function(){
			_robot.wheelMouse(isSecure(), Number(wheelAmt), Number(0), Number(duration||0));
		}, delay, duration);
	},
 
	setClipboard: function(/*String*/ data,/*String?*/ format){
		// summary:
		//		Set clipboard content.
		// description:
		//		Set data as clipboard content, overriding anything already there. The
		//		data will be put to the clipboard using the given format.
		// data:
		//		New clipboard content to set
		// format:
		//		Set this to "text/html" to put richtext to the clipboard.
		//		Otherwise, data is treated as plaintext. By default, plaintext
		//		is used.
		if(format==='text/html'){
			_robot.setClipboardHtml(isSecure(), data);
		}else{
			_robot.setClipboardText(isSecure(), data);
		}
	}
};
 
// After page has finished loading, create the applet iframe.
// Note: could eliminate dojo/ready dependency by tying this code to startRobot() call, but then users
// are required to put doh.run() inside of a dojo/ready.   Probably they are already doing that though.
ready(function(){
	// console.log("creating applet iframe");
	var iframesrc;
	var scripts = document.getElementsByTagName("script");
	for(var x = 0; x<scripts.length; x++){
		var s = scripts[x].getAttribute('src');
		if(s && (s.substr(s.length-9) == "runner.js")){
			iframesrc = s.substr(0, s.length-9)+'Robot.html';
			break;
		}
	}
 
	if(!iframesrc){
		// if user set document.domain to something else, send it to the Robot too
		iframesrc = require.toUrl("./Robot.html") + "?domain=" + escape(document.domain);
	}
	construct.place('<div id="dohrobotview" style="border:0px none; margin:0px; padding:0px; position:absolute; bottom:0px; right:0px; width:1px; height:1px; overflow:hidden; visibility:hidden; background-color:red;"></div>',
		win.body());
 
	if(!has("doh-custom-robot")){
		// load default robot when not custom def given
		construct.place('<iframe application="true" style="border:0px none; z-index:32767; padding:0px; margin:0px; position:absolute; left:0px; top:0px; height:100px; width:200px; overflow:hidden; background-color:transparent;" tabIndex="-1" src="'+iframesrc+'" ALLOWTRANSPARENCY="true"></iframe>',
			win.body());
	}else{
		// custom def given
		console.log("using custom robot");
		_robot = webdriver;
		// mix in exports
		for(var i in _robot){
			if(robot[i]&&_robot[i]){
				robot[i]=_robot[i];
			}
		}
		// continue init instead of waiting on frame
		robot._initRobot(_robot);
	}
});
 
// Start the robot as the first "test" when DOH runs.
doh.registerGroup("initialize robot", [
	{
		name: "load robot",
		timeout: 20000,
		runTest: function(){
			// first wait for robot to tell us it's loaded, i.e. that _initRobot() has been called
			return robot._loaded;
		}
	},
	{
		name: "start robot",
		timeout: 20000,
		runTest: function(){
			// then we call startRobot(), and wait it to asynchronously complete
			return robot.startRobot();
		}
	}
]);
 
// Register the killRobot() command as the last "test" to run.
// There's no good API to do this, so instead call doh.registerGroup() when the app first calls doh.run(),
// since presumably all the real tests have already been registered.   Note that doh.run() is called multiple times,
// so make sure to only call registerGroup() once.
var _oldRun = doh.run;
doh.run = function(){
	doh.registerGroup("kill robot", {
		name: "killRobot",
		timeout: 10000,
		runTest: function(){
			robot.killRobot();
		}
	});
	doh.run = _oldRun;
	doh.run();
};
 
 
return robot;
});
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
define("doh/runner", ["dojo/_base/lang"], function(lang){
 
var doh = {
	// summary:
	//		Functions for registering and running automated tests.
};
 
// intentionally define global tests and global doh symbols
// TODO: scrub these globals from tests and remove this pollution for 2.0
tests = doh;
this.doh = doh;
 
doh._line = "------------------------------------------------------------";
 
doh.debug = function(){
	// summary:
	//		takes any number of arguments and sends them to whatever debugging
	//		or logging facility is available in this environment
 
	// YOUR TEST RUNNER NEEDS TO IMPLEMENT THIS
};
 
doh.error = function(){
	// summary:
	//		logging method to be used to send Error objects, so that
	//		whatever debugging or logging facility you have can decide to treat it
	//		as an Error object and show additional information - such as stack trace
 
	// YOUR TEST RUNNER NEEDS TO IMPLEMENT THIS
};
 
doh._AssertFailure = function(msg, hint){
	if (doh.breakOnError) {
		//>>excludeStart("debuggerCrashesRhino", /^shrinksafe.comments/.test(kwArgs.optimize));
		debugger;
		//>>excludeEnd("debuggerCrashesRhino")
	}
	if(!(this instanceof doh._AssertFailure)){
		return new doh._AssertFailure(msg, hint);
	}
	if(hint){
		msg = (new String(msg||""))+" with hint: \n\t\t"+(new String(hint)+"\n");
	}
	this.message = new String(msg||"");
	return this;
};
doh._AssertFailure.prototype = new Error();
doh._AssertFailure.prototype.constructor = doh._AssertFailure;
doh._AssertFailure.prototype.name = "doh._AssertFailure";
 
doh.Deferred = function(canceller){
	this.chain = [];
	this.id = this._nextId();
	this.fired = -1;
	this.paused = 0;
	this.results = [null, null];
	this.canceller = canceller;
	this.silentlyCancelled = false;
};
 
lang.extend(doh.Deferred, {
	getTestErrback: function(cb, scope){
		// summary:
		//		Replaces outer getTextCallback's in nested situations to avoid multiple callback(true)'s
		var _this = this;
		return function(){
			try{
				cb.apply(scope||doh.global||_this, arguments);
			}catch(e){
				_this.reject(e);
			}
		};
	},
 
	getTestCallback: function(cb, scope){
		var _this = this;
		return function(){
			try{
				cb.apply(scope||doh.global||_this, arguments);
			}catch(e){
				_this.reject(e);
				return;
			}
			_this.resolve(true);
		};
	},
 
	_nextId: (function(){
		var n = 1;
		return function(){ return n++; };
	})(),
 
	cancel: function(){
		if(this.fired == -1){
			if (this.canceller){
				this.canceller(this);
			}else{
				this.silentlyCancelled = true;
			}
			if(this.fired == -1){
				this.reject(new Error("Deferred(unfired)"));
			}
		}else if(this.fired == 0 && this.results[0] && this.results[0].cancel){
			this.results[0].cancel();
		}
	},
 
	_pause: function(){
		this.paused++;
	},
 
	_unpause: function(){
		this.paused--;
		if ((this.paused == 0) && (this.fired >= 0)) {
			this._fire();
		}
	},
 
	_continue: function(res){
		this._resback(res);
		this._unpause();
	},
 
	_resback: function(res){
		this.fired = ((res instanceof Error) ? 1 : 0);
		this.results[this.fired] = res;
		this._fire();
	},
 
	_check: function(){
		if(this.fired != -1){
			if(!this.silentlyCancelled){
				throw new Error("already called!");
			}
			this.silentlyCancelled = false;
		}
	},
 
	resolve: function(res){
		this._check();
		this._resback(res);
	},
 
	reject: function(res){
		this._check();
		if(!(res instanceof Error)){
			res = new Error(res);
		}
		this._resback(res);
	},
 
	then: function(cb, eb){
		this.chain.push([cb, eb]);
		if(this.fired >= 0){
			this._fire();
		}
		return this;
	},
 
	always: function(cb){
		this.then(cb, cb);
	},
 
	otherwise: function(eb){
		this.then(null, eb);
	},
 
	isFulfilled: function(){
		return this.fired >= 0;
	},
 
	isResolved: function(){
		return this.fired == 0;
	},
 
	isRejected: function(){
		return this.fired == 1;
	},
 
	_fire: function(){
		var chain = this.chain;
		var fired = this.fired;
		var res = this.results[fired];
		var self = this;
		var cb = null;
		while(chain.length > 0 && this.paused == 0){
			// Array
			var pair = chain.shift();
			var f = pair[fired];
			if(f == null){
				continue;
			}
			try {
				res = f(res);
				fired = ((res instanceof Error) ? 1 : 0);
				if(res && res.then){
					cb = function(res){
						self._continue(res);
					};
					this._pause();
				}
			}catch(err){
				fired = 1;
				res = err;
			}
		}
		this.fired = fired;
		this.results[fired] = res;
		if((cb)&&(this.paused)){
			res.always(cb);
		}
	}
});
 
lang.extend(doh.Deferred, {
	// Back compat methods, remove for 2.0
 
	getFunctionFromArgs: function(){
		// Like lang.hitch but first arg (context) is optional
		var a = arguments;
		if((a[0])&&(!a[1])){
			if(typeof a[0] == "function"){
				return a[0];
			}else if(typeof a[0] == "string"){
				return doh.global[a[0]];
			}
		}else if((a[0])&&(a[1])){
			return lang.hitch(a[0], a[1]);
		}
		return null;
	},
 
	addCallbacks: function(cb, eb){
		this.then(cb, eb);
	},
 
 
    addCallback: function(cb, cbfn){
		var enclosed = this.getFunctionFromArgs(cb, cbfn);
		if(arguments.length > 2){
			enclosed = lang.hitch(null, enclosed, arguments, 2);
		}
		return this.then(enclosed);
	},
 
	addErrback: function(cb, cbfn){
		var enclosed = this.getFunctionFromArgs(cb, cbfn);
		if(arguments.length > 2){
			enclosed = lang.hitch(null, enclosed, arguments, 2);
		}
		return this.otherwise(enclosed);
	},
 
	addBoth: function(cb, cbfn){
		var enclosed = this.getFunctionFromArgs(cb, cbfn);
		if(arguments.length > 2){
			enclosed = lang.hitch(null, enclosed, arguments, 2);
		}
		return this.always(enclosed);
	},
 
	callback: function(val){
		this.resolve(val);
	},
 
	errback: function(val){
		this.reject(val);
	}
});
 
//
// State Keeping and Reporting
//
 
doh._testCount = 0;
doh._groupCount = 0;
doh._errorCount = 0;
doh._failureCount = 0;
doh._currentGroup = null;
doh._currentTest = null;
doh._paused = true;
 
doh._init = function(){
	this._currentGroup = null;
	this._currentTest = null;
	this._errorCount = 0;
	this._failureCount = 0;
	this.debug(this._testCount, "tests to run in", this._groupCount, "groups");
};
 
doh._groups = {};
 
//
// Test Types
//
doh._testTypes= {};
 
doh.registerTestType= function(name, initProc){
	// summary:
	//		Adds a test type and associates a function used to initialize each test of the given type
	// name: String
	//		The name of the type.
	// initProc: Function
	//		Type specific test initializer; called after the test object is created.
	doh._testTypes[name]= initProc;
};
 
doh.registerTestType("perf", function(group, tObj, type){
	// Augment the test with some specific options to make it identifiable as a
	// particular type of test so it can be executed properly.
	if(type === "perf" || tObj.testType === "perf"){
		tObj.testType = "perf";
 
		// Build an object on the root DOH class to contain all the test results.
		// Cache it on the test object for quick lookup later for results storage.
		if(!doh.perfTestResults){
			doh.perfTestResults = {};
			doh.perfTestResults[group] = {};
		}
		if(!doh.perfTestResults[group]){
			doh.perfTestResults[group] = {};
		}
		if(!doh.perfTestResults[group][tObj.name]){
			doh.perfTestResults[group][tObj.name] = {};
		}
		tObj.results = doh.perfTestResults[group][tObj.name];
 
		// If it's not set, then set the trial duration; default to 100ms.
		if(!("trialDuration" in tObj)){
			tObj.trialDuration = 100;
		}
 
		// If it's not set, then set the delay between trial runs to 100ms
		// default to 100ms to allow for GC and to make IE happy.
		if(!("trialDelay" in tObj)){
			tObj.trialDelay = 100;
		}
 
		// If it's not set, then set number of times a trial is run to 10.
		if(!("trialIterations" in tObj)){
			tObj.trialIterations = 10;
		}
	}
});
 
 
//
// Test Registration
//
var
	createFixture= function(group, test, type){
		// test is a function, string, or fixture object
		var tObj = test;
		if(lang.isString(test)){
			tObj = {
				name: test.replace("/\s/g", "_"), // FIXME: bad escapement
				runTest: new Function("t", test)
			};
		}else if(lang.isFunction(test)){
			// if we didn't get a fixture, wrap the function
			tObj = { "runTest": test };
			if(test["name"]){
				tObj.name = test.name;
			}else{
				try{
					var fStr = "function ";
					var ts = tObj.runTest+"";
					if(0 <= ts.indexOf(fStr)){
						tObj.name = ts.split(fStr)[1].split("(", 1)[0];
					}
					// doh.debug(tObj.runTest.toSource());
				}catch(e){
				}
			}
			// FIXME: try harder to get the test name here
		}else if(lang.isString(tObj.runTest)){
			tObj.runTest= new Function("t", tObj.runTest);
		}
		if(!tObj.runTest){
			return 0;
		}
 
		// if the test is designated as a particular type, do type-specific initialization
		var testType= doh._testTypes[type] || doh._testTypes[tObj.testType];
		if(testType){
			testType(group, tObj);
		}
 
		// add the test to this group
		doh._groups[group].push(tObj);
		doh._testCount++;
		doh._testRegistered(group, tObj);
 
		return tObj;
	},
 
	dumpArg= function(arg){
		if(lang.isString(arg)){
			return "string(" + arg + ")";
		} else {
			return typeof arg;
		}
	},
 
	illegalRegister= function(args, testArgPosition){
		var hint= "\targuments: ";
		for(var i= 0; i<5; i++){
			hint+= dumpArg(args[i]);
		}
		doh.debug("ERROR:");
		if(testArgPosition){
			doh.debug("\tillegal arguments provided to doh.register; the test at argument " + testArgPosition + " wasn't a test.");
		}else{
			doh.debug("\tillegal arguments provided to doh.register");
		}
		doh.debug(hint);
	};
 
doh._testRegistered = function(group, fixture){
	// slot to be filled in
};
 
doh._groupStarted = function(group){
	// slot to be filled in
};
 
doh._groupFinished = function(group, success){
	// slot to be filled in
};
 
doh._testStarted = function(group, fixture){
	// slot to be filled in
};
 
doh._testFinished = function(group, fixture, success){
	// slot to be filled in
};
 
doh._registerTest = function(group, test, type){
	// summary:
	//		add the provided test function or fixture object to the specified
	//		test group.
	// group: String
	//		string name of the group to add the test to
	// test: Function||String||Object
	//		TODOC
	// type: String?
	//		An identifier denoting the type of testing that the test performs, such
	//		as a performance test. If falsy, defaults to test.type.
 
	// get, possibly create, the group object
 
	var groupObj = this._groups[group];
	if(!groupObj){
		this._groupCount++;
		groupObj = this._groups[group] = [];
		groupObj.inFlight = 0;
	}
	if(!test){
		return groupObj;
	}
 
	// create the test fixture
	var tObj;
	if(lang.isFunction(test) || lang.isString(test) || "runTest" in test){
		return createFixture(group, test, type) ? groupObj : 0;
	}else if(lang.isArray(test)){
		// a vector of tests...
		for(var i=0; i<test.length; i++){
			tObj = createFixture(group, test[i], type);
			if(!tObj){
				this.debug("ERROR:");
				this.debug("\tillegal test is test array; more information follows...");
				return null;
			}
		}
		return groupObj;
	}else{
		// a hash of tests...
		for(var testName in test){
			var theTest = test[testName];
			if(lang.isFunction(theTest) || lang.isString(theTest)){
				tObj = createFixture(group, {name: testName, runTest: theTest}, type);
			}else{
				// should be an object
				theTest.name = theTest.name || testName;
				tObj = createFixture(group, theTest, type);
			}
			if(!tObj){
				this.debug("ERROR:");
				this.debug("\tillegal test is test hash; more information follows...");
				return null;
			}
		}
		return groupObj;
	}
};
 
doh._registerTestAndCheck = function(groupId, test, type, testArgPosition, args, setUp, tearDown){
	var amdMid = 0;
	if(groupId){
		if(type){
			// explicitly provided type; therefore don't try to get type from groupId
			var match = groupId.match(/([^\!]+)\!(.+)/);
			if(match){
				amdMid = match[1];
				groupId = match[2];
			}
		}else{
			var parts = groupId && groupId.split("!");
			if(parts.length == 3){
				amdMid = parts[0];
				groupId = parts[1];
				type = parts[2];
			}else if(parts.length == 2){
				// either (amdMid, group) or (group, type)
				if(parts[1] in doh._testTypes){
					groupId = parts[0];
					type = parts[1];
				}else{
					amdMid = parts[0];
					groupId = parts[1];
				}
			} // else, no ! and just a groupId
		}
	}
 
	var group = doh._registerTest(groupId, test, type);
	if(group){
		if(amdMid){
			group.amdMid = amdMid;
		}
		if(setUp){
			group.setUp = setUp;
		}
		if(tearDown){
			group.tearDown = tearDown;
		}
	}else{
		illegalRegister(arguments, testArgPosition);
	}
};
 
doh._registerUrl = function(/*String*/ group, /*String*/ url, /*Integer*/ timeout, /*String*/ type, /*object*/ dohArgs){
	// slot to be filled in
	this.debug("ERROR:");
	this.debug("\tNO registerUrl() METHOD AVAILABLE.");
};
 
var typeSigs = (function(){
	// Generate machinery to decode the many register signatures; these are the possible signatures.
 
	var sigs = [
		// note: to===timeout, up===setUp, down===tearDown
 
		// 1 arg
		"test", function(args, a1){doh._registerTestAndCheck("ungrouped", a1, 0, 0, args, 0, 0);},
		"url", function(args, a1){doh._registerUrl("ungrouped", a1);},
 
		// 2 args
		"group-test", function(args, a1, a2){doh._registerTestAndCheck(a1, a2, 0, 0, args, 0, 0);},
		"test-type", function(args, a1, a2){doh._registerTestAndCheck("ungrouped", a1, a2, 1, args, 0, 0);},
		"test-up", function(args, a1, a2){doh._registerTestAndCheck("ungrouped", a1, 0, 0, args, a2, 0);},
		"group-url", function(args, a1, a2){doh._registerUrl(a1, a2);},
		"url-to", function(args, a1, a2){doh._registerUrl("ungrouped", a1, a2);},
		"url-type", function(args, a1, a2){doh._registerUrl("ungrouped", a1, undefined, a2);},
		"url-args", function(args, a1, a2){doh._registerUrl("ungrouped", a1, undefined, 0, a2);},
 
		// 3 args
		"group-test-type", function(args, a1, a2, a3){doh._registerTestAndCheck(a1, a2, a3, 2, args, 0, 0);},
		"group-test-up", function(args, a1, a2, a3){doh._registerTestAndCheck(a1, a2, 0, 2, args, a3, 0);},
		"test-type-up", function(args, a1, a2, a3){doh._registerTestAndCheck("ungrouped", a1, a2, 0, args, a3, 0);},
		"test-up-down", function(args, a1, a2, a3){doh._registerTestAndCheck("ungrouped", a1, 0, 0, args, a2, a3);},
		"group-url-to", function(args, a1, a2, a3){doh._registerUrl(a1, a2, a3);},
		"group-url-type", function(args, a1, a2, a3){doh._registerUrl(a1, a2, undefined, a3);},
		"group-url-args", function(args, a1, a2, a3){doh._registerUrl(a1, a2, undefined, 0, a3);},
		"url-to-type", function(args, a1, a2, a3){doh._registerUrl("ungrouped", a1, a2, a3);},
		"url-to-args", function(args, a1, a2, a3){doh._registerUrl("ungrouped", a1, a2, 0, a3);},
		"url-type-args", function(args, a1, a2, a3){doh._registerUrl("ungrouped", a1, undefined, a2, a3);},
 
		// 4 args
		"group-test-type-up", function(args, a1, a2, a3, a4){doh._registerTestAndCheck(a1, a2, a3, 2, args, a4, 0);},
		"group-test-up-down", function(args, a1, a2, a3, a4){doh._registerTestAndCheck(a1, a2, 0, 2, args, a3, a4);},
		"test-type-up-down", function(args, a1, a2, a3, a4){doh._registerTestAndCheck("ungrouped", a1, 2, 0, args, a3, a4);},
		"group-url-to-type", function(args, a1, a2, a3, a4){doh._registerUrl(a1, a2, a3, a4);},
		"group-url-to-args", function(args, a1, a2, a3, a4){doh._registerUrl(a1, a2, a3, 0, a4);},
		"group-url-type-args", function(args, a1, a2, a3, a4){doh._registerUrl(a1, a2, undefined, a3, a4);},
		"url-to-type-args", function(args, a1, a2, a3, a4){doh._registerUrl("ungrouped", a1, a2, a3, a4);},
 
		// 5 args
		"group-test-type-up-down", function(args, a1, a2, a3, a4, a5){doh._registerTestAndCheck(a1, a2, a3, 2, args, a4, a5);},
		"group-url-to-type-args", function(args, a1, a2, a3, a4, a5){doh._registerUrl(a1, a2, a3, a4, a5);}
	];
 
	// type-ids
	// a - array
	// st - string, possible type
	// sf - string, possible function
	// s - string not a type or function
	// o - object
	// f - function
	// n - number
    // see getTypeId inside doh.register
	var argTypes = {
		group:"st.sf.s",
		test:"a.sf.o.f",
		type:"st",
		up:"f",
		down:"f",
		url:"s",
		to:"n",
		args:"o"
	};
	for(var p in argTypes){
		argTypes[p]= argTypes[p].split(".");
	}
 
	function generateTypeSignature(sig, pattern, dest, func){
		for(var nextPattern, reducedSig= sig.slice(1), typeList= argTypes[sig[0]], i=0; i<typeList.length; i++){
			nextPattern =  pattern + (pattern ? "-" : "") + typeList[i];
			if(reducedSig.length){
				generateTypeSignature(reducedSig, nextPattern, dest, func);
			}else{
				dest.push(nextPattern, func);
			}
		}
	}
 
	var typeSigs = [];
	for(var sig, func, dest, i = 0; i<sigs.length; i++){
		sig = sigs[i++].split("-");
		func = sigs[i];
		dest = typeSigs[sig.length-1] || (typeSigs[sig.length-1]= []);
		generateTypeSignature(sig, "", dest, func);
	}
	return typeSigs;
})();
 
 
doh.register = function(a1, a2, a3, a4, a5){
	/*=====
	doh.register = function(groupId, testOrTests, timeoutOrSetUp, tearDown){
	// summary:
	//		Add a test or group of tests.
	// description:
	//		Adds the test or tests given by testsOrUrl to the group given by group (if any). For URL tests, unless
	//		a group is explicitly provided the group given by the URL until the document arrives at which
	//		point the group is renamed to the title of the document. For non-URL tests, if groupId is
	//		not provided, then tests are added to the group "ungrouped"; otherwise if the given groupId does not
	//		exist, it is created; otherwise, tests are added to the already-existing group.
	//
	//		groupIds may contain embedded AMD module identifiers as prefixes and/or test types as suffixes. Prefixes
	//		and suffixes are denoted by a "!". For example
	// groupId: String?
	//		The name of the group, optionally with an AMD module identifier prefix and/or
	//		test type suffix. The value character set for group names and AMD module indentifiers
	//		is given by [A-Za-z0-9_/.-]. If provided, prefix and suffix are denoted by "!". If
	//		provided, type must be a valid test type.
	// testOrTests: Array||Function||Object||String||falsy
	//		When a function, implies a function that defines a single test. DOH passes the
	//		DOH object to the function as the sole argument when the test is executed. When
	//		a string, implies the definition of a single test given by `new Function("t", testOrTests)`.
	//		When an object that contains the method `runTest` (which *must* be a function),
	//		implies a single test given by the value of the property `runTest`. In this case,
	//		the object may also contain the methods `setup` and `tearDown`, and, if provided, these
	//		will be invoked on either side of the test function. Otherwise when an object (that is,
	//		an object that does not contain the method `runTest`), then a hash from test name to
	//		test function (either a function or string as described above); any names that begin
	//		with "_" are ignored. When an array, the array must exclusively contain functions,
	//		strings, and/or objects as described above and each item is added to the group as
	//		per the items semantics.
	// timeoutOrSetUp: integer||Function?
	//		If tests is a URL, then must be an integer giving the number milliseconds to wait for the test
	//		page to load before signaling an error; otherwise, a function for initializing the test group.
	//		If a tearDown function is given, then a setup function must also be given.
	// tearDown: Function?
	//		A function for deinitializing the test group.
	// example:
	// | `"myTest/MyGroup"`							// just a group, group ids need not include a slash
	// | `"myTest/MyGroup!perf"`					// group with test type
	// | `"path/to/amd/module!myTest/MyGroup"`		// group with AMD module identifier
	// | `"path/to/amd/module!myTest/MyGroup!perf"`	// group with both AMD module identifier and test type
	//
	//		Groups associated with AMD module identifiers may be unloaded/reloaded if using an AMD loader with
	//		reload support (dojo's AMD loader includes such support). If no AMD module identifier is given,
	//		the loader supports reloading, and the user demands a reload, then the groupId will be used
	//		as the AMD module identifier.
	//
	//		For URL tests, the groupId is changed to the document title (if any) upon document arrival. The
	//		title may include a test type suffix denoted with a "!" as described above.
	//
	//		For URL tests, if timeout is a number, then sets the timeout for loading
	//		the particular URL; otherwise, timeout is set to DOH.iframeTimeout.
	//
	//		For non-URL tests, if setUp and/or tearDown are provided, then any previous setUp and/or
	//		tearDown functions for the group are replaced as given. You may affect just setUp and/or tearDown
	//		for a group and not provide/add any tests by providing falsy for the test argument.
	// example:
	// | var
	// |	t1= function(t) {
	// |		// this is a test
	// |		// t will be set to DOH when the test is executed by DOH
	// |		// etc.
	// |	},
	// |
	// |	t2= {
	// |		// this is a test fixture and may be passed as a test
	// |
	// |		// runTest is always required...
	// |		runTest: function(t){
	// |			// the test...
	// |		},
	// |
	// |		// name is optional, but recommended...
	// |		name:"myTest",
	// |
	// |		// preamble is optional...
	// |		setUp: function(){
	// |			// will be executed by DOH prior to executing the test
	// |		},
	// |
	// |		// postscript is optional...
	// |		tearDown: function(){ // op
	// |			// will be executed by DOH after executing the test
	// |		}
	// |	}
	// |
	// |	t3= [
	// |		// this is a vector of tests...
	// |		t1, t2
	// |	],
	// |
	// |	t4= {
	// |		// this is a map from test name to test or test fixture
	// |		t5: function(t){
	// |			// etc.
	// |		},
	// |
	// |		t6: {
	// |			runTest: function(t){
	// |			// etc.
	// |			}
	// |			// name will be automatically added as "t6"
	// |		}
	// |	},
	// |
	// |	aSetup: function(){
	// |		// etc.
	// |	},
	// |
	// |	aTearDown: function(){
	// |		// etc.
	// |	};
	// | // (test); note, can't provide setup/tearDown without a group
	// | doh.register(t1);
	// |
	// | // (group, test, setUp, tearDown) test and/or setUp and/or tearDown can be missing
	// | doh.register("myGroup", 0, aSetUp, aTearDown);
	// | doh.register("myGroup", t1, aSetUp, aTearDown);
	// | doh.register("myGroup", t1, aSetUp);
	// | doh.register("myGroup", t1, 0, aTearDown);
	// | doh.register("myGroup", t1);
	// |
	// | // various kinds of test arguments are allowed
	// | doh.register("myGroup", t2);
	// | doh.register("myGroup", t3);
	// | doh.register("myGroup", t4);
	// |
	// | // add a perf test
	// | doh.register("myGroup!perf", t1);
	// |
	// | // add a perf test with an AMD module identifier
	// | doh.register("path/to/my/module!myGroup!perf", t1);
	//
	//	doh.register also supports Dojo, v1.6- signature (group, test, type), although this signature is deprecated.
	};
	=====*/
 
	function getTypeId(a){
		if(a instanceof Array){
			return "a";
		}else if(typeof a == "function"){
			return "f";
		}else if(typeof a == "number"){
			return "n";
		}else if(typeof a == "string"){
			if(a in doh._testTypes){
				return "st";
			}else if(/\(/.test(a)){
				return "sf";
			}else{
				return "s";
			}
		}else{
			return "o";
		}
	}
 
	var
		arity = arguments.length,
		search = typeSigs[arity-1],
		sig = [],
		i;
	for(i =0; i<arity; i++){
		sig.push(getTypeId(arguments[i]));
	}
	sig = sig.join("-");
	for(i=0; i<search.length; i+= 2){
		if(search[i]==sig){
			search[i+1](arguments, a1, a2, a3, a4, a5);
			return;
		}
	}
	illegalRegister(arguments);
};
 
doh.registerDocTests = function(module){
	// summary:
	//		Deprecated.    Won't work unless you manually load dojox.testing.DocTest, and likely not even then.
	//		Gets all the doctests from the given module and register each of them as a single test case here.
 
	var docTest = new dojox.testing.DocTest();
	var docTests = docTest.getTests(module);
	var len = docTests.length;
	var tests = [];
	for (var i=0; i<len; i++){
		var test = docTests[i];
		// Extract comment on first line and add to test name.
		var comment = "";
		if (test.commands.length && test.commands[0].indexOf("//")!=-1) {
			var parts = test.commands[0].split("//");
			comment = ", "+parts[parts.length-1]; // Get all after the last //, so we don't get trapped by http:// or alikes :-).
		}
		tests.push({
			runTest: (function(test){
				return function(t){
					var r = docTest.runTest(test.commands, test.expectedResult);
					t.assertTrue(r.success);
				};
			})(test),
			name:"Line "+test.line+comment
		}
		);
	}
	this.register("DocTests: "+module, tests);
};
 
//
// deprecated v1.6- register API follows
//
 
doh.registerTest = function(/*String*/ group, /*Array||Function||Object*/ test, /*String*/ type){
	// summary:
	//		Deprecated.  Use doh.register(group/type, test) instead
	doh.register(group + (type ? "!" + type : ""), test);
};
 
doh.registerGroup = function(/*String*/ group, /*Array||Function||Object*/ tests, /*Function*/ setUp, /*Function*/ tearDown, /*String*/ type){
	// summary:
	//		Deprecated.  Use doh.register(group/type, tests, setUp, tearDown) instead
	var args = [(group ? group : "") + (type ? "!" + type : ""), tests];
	setUp && args.push(setUp);
	tearDown && args.push(tearDown);
	doh.register.apply(doh, args);
};
 
doh.registerTestNs = function(/*String*/ group, /*Object*/ ns){
	// summary:
	//		Deprecated.  Use doh.register(group, ns) instead
	doh.register(group, ns);
};
 
doh.registerTests = function(/*String*/ group, /*Array*/ testArr, /*String*/ type){
	// summary:
	//		Deprecated.  Use doh.register(group/type, testArr) instead
	doh.register(group + (type ? "!" + type : ""), testArr);
};
 
doh.registerUrl = function(/*String*/ group, /*String*/ url, /*Integer*/ timeout, /*String*/ type, /*Object*/ args){
	// summary:
	//		Deprecated.  Use doh.register(group/type, url, timeout) instead
	doh.register(group + (type ? "!" + type : ""), url+"", timeout || 10000, args || {});
};
 
//
// Assertions and In-Test Utilities
//
doh.t = doh.assertTrue = function(/*Object*/ condition, /*String?*/ hint){
	// summary:
	//		is the passed item "truthy"?
	if(arguments.length < 1){
		throw new doh._AssertFailure("assertTrue failed because it was not passed at least 1 argument");
	}
	//if(lang.isString(condition) && condition.length){
	//	return true;
	//}
	if(!eval(condition)){
		throw new doh._AssertFailure("assertTrue('" + condition + "') failed", hint);
	}
};
 
doh.f = doh.assertFalse = function(/*Object*/ condition, /*String?*/ hint){
	// summary:
	//		is the passed item "falsey"?
	if(arguments.length < 1){
		throw new doh._AssertFailure("assertFalse failed because it was not passed at least 1 argument");
	}
	if(eval(condition)){
		throw new doh._AssertFailure("assertFalse('" + condition + "') failed", hint);
	}
};
 
doh.e = doh.assertError = function(/*Error object*/expectedError, /*Object*/scope, /*String*/functionName, /*Array*/args, /*String?*/ hint){
	// summary:
	//		Test for a certain error to be thrown by the given function.
	// example:
	//		t.assertError(dojox.data.QueryReadStore.InvalidAttributeError, store, "getValue", [item, "NOT THERE"]);
	//		t.assertError(dojox.data.QueryReadStore.InvalidItemError, store, "getValue", ["not an item", "NOT THERE"]);
	try{
		scope[functionName].apply(scope, args);
	}catch (e){
		if(e instanceof expectedError){
 
			return true;
		}else{
			throw new doh._AssertFailure("assertError() failed:\n\texpected error\n\t\t"+expectedError+"\n\tbut got\n\t\t"+e+"\n\n", hint);
		}
	}
	throw new doh._AssertFailure("assertError() failed:\n\texpected error\n\t\t"+expectedError+"\n\tbut no error caught\n\n", hint);
};
 
doh.is = doh.assertEqual = function(/*Object*/ expected, /*Object*/ actual, /*String?*/ hint, doNotThrow){
	// summary:
	//		are the passed expected and actual objects/values deeply
	//		equivalent?
 
	// Compare undefined always with three equal signs, because undefined==null
	// is true, but undefined===null is false.
	if((expected === undefined)&&(actual === undefined)){
		return true;
	}
	if(arguments.length < 2){
		throw doh._AssertFailure("assertEqual failed because it was not passed 2 arguments");
	}
	if((expected === actual)||(expected == actual)||
				( typeof expected == "number" && typeof actual == "number" && isNaN(expected) && isNaN(actual) )){
 
		return true;
	}
	if( (lang.isArray(expected) && lang.isArray(actual))&&
		(this._arrayEq(expected, actual)) ){
		return true;
	}
	if( ((typeof expected == "object")&&((typeof actual == "object")))&&
		(this._objPropEq(expected, actual)) ){
		return true;
	}
	if (doNotThrow) {
		return false;
	}
	throw new doh._AssertFailure("assertEqual() failed:\n\texpected\n\t\t"+expected+"\n\tbut got\n\t\t"+actual+"\n\n", hint);
};
 
doh.isNot = doh.assertNotEqual = function(/*Object*/ notExpected, /*Object*/ actual, /*String?*/ hint){
	// summary:
	//		are the passed notexpected and actual objects/values deeply
	//		not equivalent?
 
	// Compare undefined always with three equal signs, because undefined==null
	// is true, but undefined===null is false.
	if((notExpected === undefined)&&(actual === undefined)){
				throw new doh._AssertFailure("assertNotEqual() failed: not expected |"+notExpected+"| but got |"+actual+"|", hint);
	}
	if(arguments.length < 2){
		throw doh._AssertFailure("assertEqual failed because it was not passed 2 arguments");
	}
	if((notExpected === actual)||(notExpected == actual)){
				throw new doh._AssertFailure("assertNotEqual() failed: not expected |"+notExpected+"| but got |"+actual+"|", hint);
	}
	if( (lang.isArray(notExpected) && lang.isArray(actual))&&
		(this._arrayEq(notExpected, actual)) ){
		throw new doh._AssertFailure("assertNotEqual() failed: not expected |"+notExpected+"| but got |"+actual+"|", hint);
	}
	if( ((typeof notExpected == "object")&&((typeof actual == "object"))) ){
		var isequal = false;
		try{
			isequal = this._objPropEq(notExpected, actual);
		}catch(e){
			if(!(e instanceof doh._AssertFailure)){
				throw e; // other exceptions, just throw it
			}
		}
		if(isequal){
				throw new doh._AssertFailure("assertNotEqual() failed: not expected |"+notExpected+"| but got |"+actual+"|", hint);
		}
	}
	return true;
};
 
doh._arrayEq = function(expected, actual){
	if(expected.length != actual.length){ return false; }
	// FIXME: we're not handling circular refs. Do we care?
	for(var x=0; x<expected.length; x++){
		if(!doh.assertEqual(expected[x], actual[x], 0, true)){ return false; }
	}
	return true;
};
 
doh._objPropEq = function(expected, actual){
	// Degenerate case: if they are both null, then their "properties" are equal.
	if(expected === null && actual === null){
		return true;
	}
	// If only one is null, they aren't equal.
	if(expected === null || actual === null){
		return false;
	}
	if(expected instanceof Date){
		return actual instanceof Date && expected.getTime()==actual.getTime();
	}
	var x;
	// Make sure ALL THE SAME properties are in both objects!
	for(x in actual){ // Lets check "actual" here, expected is checked below.
		if(!(x in expected)){
			return false;
		}
	}
 
	for(x in expected){
		if(!(x in actual)){
			return false;
		}
		if(!doh.assertEqual(expected[x], actual[x], 0, true)){
			return false;
		}
	}
	return true;
};
 
//
// Runner-Wrapper
//
 
doh._setupGroupForRun = function(/*String*/ groupName){
	var tg = this._groups[groupName];
	this.debug(this._line);
	this.debug("GROUP", "\""+groupName+"\"", "has", tg.length, "test"+((tg.length > 1) ? "s" : "")+" to run");
	doh._groupStarted(groupName);
};
 
doh._handleFailure = function(groupName, fixture, e){
	// this.debug("FAILED test:", fixture.name);
	// mostly borrowed from JUM
	this._groups[groupName].failures++;
	var out = "";
	if(e instanceof this._AssertFailure){
		this._failureCount++;
		if(e["fileName"]){ out += e.fileName + ':'; }
		if(e["lineNumber"]){ out += e.lineNumber + ' '; }
		out += e.message;
		this.error("\t_AssertFailure:", out);
	}else{
		this._errorCount++;
		this.error("\tError:", e.message || e); // printing Error on IE9 (and other browsers?) yields "[Object Error]"
	}
	if(fixture.runTest["toSource"]){
		var ss = fixture.runTest.toSource();
		this.debug("\tERROR IN:\n\t\t", ss);
	}else{
		this.debug("\tERROR IN:\n\t\t", fixture.runTest);
	}
	if(e.rhinoException){
		e.rhinoException.printStackTrace();
	}else if(e.javaException){
		e.javaException.printStackTrace();
	}
};
 
doh._runPerfFixture = function(/*String*/ groupName, /*Object*/ fixture){
	// summary:
	//		This function handles how to execute a 'performance' test
	//		which is different from a straight UT style test.  These
	//		will often do numerous iterations of the same operation and
	//		gather execution statistics about it, like max, min, average,
	//		etc.	It makes use of the already in place DOH deferred test
	//		handling since it is a good idea to put a pause in between each
	//		iteration to allow for GC cleanup and the like.
	// groupName:
	//		The test group that contains this performance test.
	// fixture:
	//		The performance test fixture.
	var tg = this._groups[groupName];
	fixture.startTime = new Date();
 
	// Perf tests always need to act in an async manner as there is a
	// number of iterations to flow through.
	var def = new doh.Deferred();
	tg.inFlight++;
	def.groupName = groupName;
	def.fixture = fixture;
 
	var threw = false;
	def.otherwise(function(err){
		doh._handleFailure(groupName, fixture, err);
		threw = true;
	});
 
	// Set up the finalizer.
	var fulfilled;
	var retEnd = function(){
		fulfilled = true;
		if(fixture["tearDown"]){ fixture.tearDown(doh); }
		tg.inFlight--;
		if((!tg.inFlight)&&(tg.iterated)){
			doh._groupFinished(groupName, !tg.failures);
		}
		doh._testFinished(groupName, fixture, !threw);
		if(doh._paused){
			doh.run();
		}
	};
 
	// Since these can take who knows how long, we don't want to timeout
	// unless explicitly set
	var timer;
	var to = fixture.timeout;
	if(to > 0) {
		timer = setTimeout(function(){
			def.reject(new Error("test timeout in "+fixture.name.toString()));
		}, to);
	}
 
	// Set up the end calls to the test into the deferred we'll return.
	def.always(function(){
		if(timer){
			clearTimeout(timer);
		}
		retEnd();
	});
 
	// Okay, now set up the timing loop for the actual test.
	// This is down as an async type test where there is a delay
	// between each execution to allow for GC time, etc, so the GC
	// has less impact on the tests.
	var res = fixture.results;
	res.trials = [];
 
	// Try to figure out how many calls are needed to hit a particular threshold.
	var itrDef = doh._calcTrialIterations(groupName, fixture);
 
	// Blah, since tests can be deferred, the actual run has to be deferred until after
	// we know how many iterations to run.  This is just plain ugly.
	itrDef.then(
		function(iterations){
			if(iterations){
				var countdown = fixture.trialIterations;
				doh.debug("TIMING TEST: [" + fixture.name +
							"]\n\t\tITERATIONS PER TRIAL: " +
							iterations + "\n\tTRIALS: " +
							countdown);
 
				// Figure out how many times we want to run our 'trial'.
				// Where each trial consists of 'iterations' of the test.
 
				var trialRunner = function() {
					// Set up our function to execute a block of tests
					var start = new Date();
					var tTimer = new doh.Deferred();
 
					var tState = {
						countdown: iterations
					};
					var testRunner = function(state){
						while(state){
							try{
								state.countdown--;
								if(state.countdown){
									var ret = fixture.runTest(doh);
									if(ret && ret.then){
										// Deferreds have to be handled async,
										// otherwise we just keep looping.
										var atState = {
											countdown: state.countdown
										};
										ret.then(
											function(){
												testRunner(atState)
											},
											function(err){
												doh._handleFailure(groupName, fixture, err);
												fixture.endTime = new Date();
												def.reject(err);
											}
										);
										state = null;
									}
								}else{
									tTimer.resolve(new Date());
									state = null;
								}
							}catch(err){
								fixture.endTime = new Date();
								tTimer.reject(err);
							}
						}
					};
					tTimer.then(
						function(end){
							// Figure out the results and try to factor out function call costs.
							var tResults = {
								trial: (fixture.trialIterations - countdown),
								testIterations: iterations,
								executionTime: (end.getTime() - start.getTime()),
								average: (end.getTime() - start.getTime())/iterations
							};
							res.trials.push(tResults);
							doh.debug("\n\t\tTRIAL #: " +
										tResults.trial + "\n\tTIME: " +
										tResults.executionTime + "ms.\n\tAVG TEST TIME: " +
										(tResults.executionTime/tResults.testIterations) + "ms.");
 
							// Okay, have we run all the trials yet?
							countdown--;
							if(countdown){
								setTimeout(trialRunner, fixture.trialDelay);
							}else{
								// Okay, we're done, let's compute some final performance results.
								var t = res.trials;
 
								// We're done.
								fixture.endTime = new Date();
								def.resolve(true);
							}
						},
 
						// Handler if tTimer gets an error
						function(err){
							fixture.endTime = new Date();
							def.reject(err);
						}
					);
					testRunner(tState);
				};
				trialRunner();
			}
		},
 
		// Handler if itrDef gets an error
		function(err){
			fixture.endTime = new Date();
			def.reject(err);
		}
	);
 
	// Set for a pause, returned the deferred.
	if(!fulfilled){
		doh.pause();
	}
	return def;
};
 
doh._calcTrialIterations =	function(/*String*/ groupName, /*Object*/ fixture){
	// summary:
	//		This function determines the rough number of iterations to
	//		use to reach a particular MS threshold.  This returns a deferred
	//		since tests can theoretically by async.  Async tests aren't going to
	//		give great perf #s, though.
	//		The callback is passed the # of iterations to hit the requested
	//		threshold.
	// fixture:
	//		The test fixture we want to calculate iterations for.
	var def = new doh.Deferred();
	var calibrate = function () {
		var testFunc = lang.hitch(fixture, fixture.runTest);
 
		// Set the initial state.	We have to do this as a loop instead
		// of a recursive function.	Otherwise, it blows the call stack
		// on some browsers.
		var iState = {
			start: new Date(),
			curIter: 0,
			iterations: 5
		};
		var handleIteration = function(state){
			while(state){
				if(state.curIter < state.iterations){
					try{
						var ret = testFunc(doh);
						if(ret && ret.then){
							var aState = {
								start: state.start,
								curIter: state.curIter + 1,
								iterations: state.iterations
							};
							ret.then(
								function(){
									handleIteration(aState);
								},
								function(err) {
									fixture.endTime = new Date();
									def.reject(err);
								}
							);
							state = null;
						}else{
							state.curIter++;
						}
					}catch(err){
						fixture.endTime = new Date();
						def.reject(err);
						return;
					}
				}else{
					var end = new Date();
					var totalTime = (end.getTime() - state.start.getTime());
					if(totalTime < fixture.trialDuration){
						var nState = {
							iterations: state.iterations * 2,
							curIter: 0
						};
						state = null;
						setTimeout(function(){
							nState.start = new Date();
							handleIteration(nState);
						}, 50);
					}else{
						var itrs = state.iterations;
						setTimeout(function(){def.resolve(itrs)}, 50);
						state = null;
					}
				}
			}
		};
		handleIteration(iState);
	};
	setTimeout(calibrate, 10);
	return def;
};
 
doh._runRegFixture = function(/*String*/ groupName, /*Object*/ fixture){
	// summary:
	//		Function to help run a generic doh test.  Called from _runFixture().  These are not
	//		specialized tests, like performance groups and such.
	// groupName:
	//		The groupName of the test.
	// fixture:
	//		The test fixture to execute.
 
	var tg = this._groups[groupName];
 
	fixture.startTime = new Date();
 
	var ret = fixture.runTest(this);
 
	// if we get a deferred back from the test runner, we know we're
	// gonna wait for an async result. It's up to the test code to trap
	// errors and give us an errback or callback.
	if(ret && ret.then){
 
		// If ret is a dojo/Deferred, get the corresponding Promise; it has some additional methods we need.
		if(ret.promise){
			ret = ret.promise;
		}
 
		tg.inFlight++;
		ret.groupName = groupName;
		ret.fixture = fixture;
 
		// Setup handler for when test fails.
		var threw = false;
		ret.otherwise(function(err){
			if(threw){
				// the fixture timeout (below) must have already fired
				return;
			}
			doh._handleFailure(groupName, fixture, err);
			threw = true;
		});
 
		var fulfilled;
		var retEnd = function(){
			// summary:
			//		Called when tests finishes successfully, fails, or times out
 
			if(fulfilled){
				// retEnd() has already executed; probably the timeout above fired and then later ret completed.
				return;
			}
			fulfilled = true;
 
			fixture.endTime = new Date();
 
			if(fixture.tearDown){
				try {
					fixture.tearDown(doh);
				}catch(e){
					this.debug("Error tearing down test: "+e.message);
				}
			}
			tg.inFlight--;
			doh._testFinished(groupName, fixture, !threw);
 
			if((!tg.inFlight)&&(tg.iterated)){
				doh._groupFinished(groupName, !tg.failures);
			}
 
			// Go on to next test
			if(doh._paused){
				doh.run();
			}
		};
 
		var timer = setTimeout(function(){
			if(!timer){
				// we already called clearTimeout(), but it fired anyway, due to IE bug; just ignore.
				return;
			}
			// Note: cannot call ret.reject() because ret may be a readonly promise
			doh._handleFailure(groupName, fixture, new Error("test timeout in " + fixture.name.toString()));
			threw = true;
			retEnd();
		}, fixture["timeout"]||100000);
 
		ret.always(function(){
			clearTimeout(timer);
			timer = null;
			retEnd();
		});
 
		if(!fulfilled){
			doh.pause();
		}
 
		return ret;
	}else{
		// Synchronous test; tearDown etc. handled in _runFixture(), the function that called me
	}
};
 
doh._runFixture = function(groupName, fixture){
	var tg = this._groups[groupName];
	this._testStarted(groupName, fixture);
	var threw = false;
	var err = null;
	// run it, catching exceptions and reporting them
	try{
		// let doh reference "this.group.thinger..." which can be set by
		// another test or group-level setUp function
		fixture.group = tg;
		// only execute the parts of the fixture we've got
 
		if(fixture["setUp"]){ fixture.setUp(this); }
		if(fixture["runTest"]){		// should we error out of a fixture doesn't have a runTest?
			if(fixture.testType === "perf"){
				// Always async deferred, so return it.
				return doh._runPerfFixture(groupName, fixture);
			}else{
				// May or may not by async.
				var ret = doh._runRegFixture(groupName, fixture);
				if(ret){
					// this design is ridiculous, but tearDown etc. is handled in _runRegFixture iff fixture is async;
					// likewise with runPerfFixture
					return ret;
				}
			}
		}
	}catch(e){
		threw = true;
		err = e;
	}
 
	// The rest of the code in this function executes only if test returns synchronously...
 
	fixture.endTime = new Date();
 
	// should try to tear down regardless whether test passed or failed...
	try{
		if(fixture["tearDown"]){ fixture.tearDown(this); }
	}catch(e){
		this.debug("Error tearing down test: "+e.message);
	}
 
	var d = new doh.Deferred();
	setTimeout(lang.hitch(this, function(){
		if(threw){
			this._handleFailure(groupName, fixture, err);
		}
		this._testFinished(groupName, fixture, !threw);
 
		if((!tg.inFlight)&&(tg.iterated)){
			doh._groupFinished(groupName, !tg.failures);
		}else if(tg.inFlight > 0){
			setTimeout(lang.hitch(this, function(){
				doh.runGroup(groupName);
			}), 100);
			this._paused = true;
		}
		if(doh._paused){
			doh.run();
		}
	}), 30);
	doh.pause();
	return d;
};
 
doh.runGroup = function(/*String*/ groupName, /*Integer*/ idx){
	// summary:
	//		runs the specified test group
 
	// the general structure of the algorithm is to run through the group's
	// list of doh, checking before and after each of them to see if we're in
	// a paused state. This can be caused by the test returning a deferred or
	// the user hitting the pause button. In either case, we want to halt
	// execution of the test until something external to us restarts it. This
	// means we need to pickle off enough state to pick up where we left off.
 
	// FIXME: need to make fixture execution async!!
 
	idx = idx || 0;
	var tg = this._groups[groupName];
	if(tg.skip === true){ return; }
	if(lang.isArray(tg)){
		if(tg.iterated===undefined){
			tg.iterated = false;
			tg.inFlight = 0;
			tg.failures = 0;
			this._setupGroupForRun(groupName);
			if(tg["setUp"]){ tg.setUp(this); }
		}
		for(var y=idx; y<tg.length; y++){
			if(this._paused){
				this._currentTest = y;
				// this.debug("PAUSED at:", tg[y].name, this._currentGroup, this._currentTest);
				return;
			}
			doh._runFixture(groupName, tg[y]);
			if(this._paused){
				this._currentTest = y+1;
				if(this._currentTest == tg.length){ // RCG--don't think we need this; the next time through it will be taken care of
					tg.iterated = true;
				}
				// this.debug("PAUSED at:", tg[y].name, this._currentGroup, this._currentTest);
				return;
			}
		}
		tg.iterated = true;
		if(!tg.inFlight){
			if(tg["tearDown"]){ tg.tearDown(this); }
			doh._groupFinished(groupName, !tg.failures);
		}
	}
};
 
doh._onEnd = function(){};
 
doh._report = function(){
	// summary:
	//		a private method to be implemented/replaced by the "locally
	//		appropriate" test runner
 
	// this.debug("ERROR:");
	// this.debug("\tNO REPORTING OUTPUT AVAILABLE.");
	// this.debug("\tIMPLEMENT doh._report() IN YOUR TEST RUNNER");
 
	this.debug(this._line);
	this.debug("| TEST SUMMARY:");
	this.debug(this._line);
	this.debug("\t", this._testCount, "tests in", this._groupCount, "groups");
	this.debug("\t", this._errorCount, "errors");
	this.debug("\t", this._failureCount, "failures");
};
 
doh.togglePaused = function(){
	this[(this._paused) ? "run" : "pause"]();
};
 
doh.pause = function(){
	// summary:
	//		halt test run. Can be resumed.
	this._paused = true;
};
 
doh.run = function(){
	// summary:
	//		begins or resumes the test process.
	
	this._paused = false;
	var cg = this._currentGroup;
	var ct = this._currentTest;
	var found = false;
	if(!cg){
		this._init(); // we weren't paused
		found = true;
	}
	this._currentGroup = null;
	this._currentTest = null;
	for(var x in this._groups){
		if(
			( (!found)&&(x == cg) )||( found )
		){
			if(this._paused){ return; }
			this._currentGroup = x;
			if(!found){
				found = true;
				this.runGroup(x, ct);
			}else{
				this.runGroup(x);
			}
			if(this._paused){ return; }
		}
	}
	this._currentGroup = null;
	this._currentTest = null;
	this._paused = false;
	this._onEnd();
	this._report();
};
 
doh.runOnLoad = function(){
	require(["dojo/ready"], function(ready){
		ready(doh, "run");
	});
};
 
return doh;
 
});
 
// backcompat hack: if in the browser, then loading doh/runner implies loading doh/_browserRunner. This is the
// behavior of 1.6- and is leveraged on many test documents that dojo.require("doh.runner"). Note that this
// hack will only work in synchronous mode; but if you're not in synchronous mode, you don't care about this.
// Remove for 2.0.
if (typeof window!="undefined" && typeof location!="undefined" && typeof document!="undefined" && window.location==location && window.document==document) {
	require(["doh/_browserRunner"]);
}